    {-# LANGUAGE TypeApplications #-}

    -- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- A t'GI.Pango.Structs.LayoutIter.LayoutIter' structure can be used to
    -- iterate over the visual extents of a t'GI.Pango.Objects.Layout.Layout'.
    --
    -- The t'GI.Pango.Structs.LayoutIter.LayoutIter' structure is opaque, and
    -- has no user-visible fields.

    #if !defined(__HADDOCK_VERSION__)
    #define ENABLE_OVERLOADING
    #endif

    module GI.Pango.Structs.LayoutIter
        (

    -- * Exported types
        LayoutIter(..)                          ,

     -- * Methods
    -- ** Overloaded methods #method:Overloaded methods#

    #if defined(ENABLE_OVERLOADING)
        ResolveLayoutIterMethod                 ,
    #endif

    -- ** atLastLine #method:atLastLine#

    #if defined(ENABLE_OVERLOADING)
        LayoutIterAtLastLineMethodInfo          ,
    #endif
        layoutIterAtLastLine                    ,

    -- ** copy #method:copy#

    #if defined(ENABLE_OVERLOADING)
        LayoutIterCopyMethodInfo                ,
    #endif
        layoutIterCopy                          ,

    -- ** free #method:free#

    #if defined(ENABLE_OVERLOADING)
        LayoutIterFreeMethodInfo                ,
    #endif
        layoutIterFree                          ,

    -- ** getBaseline #method:getBaseline#

    #if defined(ENABLE_OVERLOADING)
        LayoutIterGetBaselineMethodInfo         ,
    #endif
        layoutIterGetBaseline                   ,

    -- ** getCharExtents #method:getCharExtents#

    #if defined(ENABLE_OVERLOADING)
        LayoutIterGetCharExtentsMethodInfo      ,
    #endif
        layoutIterGetCharExtents                ,

    -- ** getClusterExtents #method:getClusterExtents#

    #if defined(ENABLE_OVERLOADING)
        LayoutIterGetClusterExtentsMethodInfo   ,
    #endif
        layoutIterGetClusterExtents             ,

    -- ** getIndex #method:getIndex#

    #if defined(ENABLE_OVERLOADING)
        LayoutIterGetIndexMethodInfo            ,
    #endif
        layoutIterGetIndex                      ,

    -- ** getLayout #method:getLayout#

    #if defined(ENABLE_OVERLOADING)
        LayoutIterGetLayoutMethodInfo           ,
    #endif
        layoutIterGetLayout                     ,

    -- ** getLayoutExtents #method:getLayoutExtents#

    #if defined(ENABLE_OVERLOADING)
        LayoutIterGetLayoutExtentsMethodInfo    ,
    #endif
        layoutIterGetLayoutExtents              ,

    -- ** getLine #method:getLine#

    #if defined(ENABLE_OVERLOADING)
        LayoutIterGetLineMethodInfo             ,
    #endif
        layoutIterGetLine                       ,

    -- ** getLineExtents #method:getLineExtents#

    #if defined(ENABLE_OVERLOADING)
        LayoutIterGetLineExtentsMethodInfo      ,
    #endif
        layoutIterGetLineExtents                ,

    -- ** getLineReadonly #method:getLineReadonly#

    #if defined(ENABLE_OVERLOADING)
        LayoutIterGetLineReadonlyMethodInfo     ,
    #endif
        layoutIterGetLineReadonly               ,

    -- ** getLineYrange #method:getLineYrange#

    #if defined(ENABLE_OVERLOADING)
        LayoutIterGetLineYrangeMethodInfo       ,
    #endif
        layoutIterGetLineYrange                 ,

    -- ** getRun #method:getRun#

    #if defined(ENABLE_OVERLOADING)
        LayoutIterGetRunMethodInfo              ,
    #endif
        layoutIterGetRun                        ,

    -- ** getRunExtents #method:getRunExtents#

    #if defined(ENABLE_OVERLOADING)
        LayoutIterGetRunExtentsMethodInfo       ,
    #endif
        layoutIterGetRunExtents                 ,

    -- ** getRunReadonly #method:getRunReadonly#

    #if defined(ENABLE_OVERLOADING)
        LayoutIterGetRunReadonlyMethodInfo      ,
    #endif
        layoutIterGetRunReadonly                ,

    -- ** nextChar #method:nextChar#

    #if defined(ENABLE_OVERLOADING)
        LayoutIterNextCharMethodInfo            ,
    #endif
        layoutIterNextChar                      ,

    -- ** nextCluster #method:nextCluster#

    #if defined(ENABLE_OVERLOADING)
        LayoutIterNextClusterMethodInfo         ,
    #endif
        layoutIterNextCluster                   ,

    -- ** nextLine #method:nextLine#

    #if defined(ENABLE_OVERLOADING)
        LayoutIterNextLineMethodInfo            ,
    #endif
        layoutIterNextLine                      ,

    -- ** nextRun #method:nextRun#

    #if defined(ENABLE_OVERLOADING)
        LayoutIterNextRunMethodInfo             ,
    #endif
        layoutIterNextRun                       ,

        ) where

    import Data.GI.Base.ShortPrelude
    import qualified Data.GI.Base.ShortPrelude as SP
    import qualified Data.GI.Base.Overloading as O
    import qualified Prelude as P

    import qualified Data.GI.Base.Attributes as GI.Attributes
    import qualified Data.GI.Base.BasicTypes as B.Types
    import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
    import qualified Data.GI.Base.GArray as B.GArray
    import qualified Data.GI.Base.GClosure as B.GClosure
    import qualified Data.GI.Base.GError as B.GError
    import qualified Data.GI.Base.GVariant as B.GVariant
    import qualified Data.GI.Base.GValue as B.GValue
    import qualified Data.GI.Base.GParamSpec as B.GParamSpec
    import qualified Data.GI.Base.CallStack as B.CallStack
    import qualified Data.GI.Base.Properties as B.Properties
    import qualified Data.GI.Base.Signals as B.Signals
    import qualified Control.Monad.IO.Class as MIO
    import qualified Data.Text as T
    import qualified Data.ByteString.Char8 as B
    import qualified Data.Map as Map
    import qualified Foreign.Ptr as FP
    import qualified GHC.OverloadedLabels as OL

    import {-# SOURCE #-} qualified GI.Pango.Objects.Layout as Pango.Layout
    import {-# SOURCE #-} qualified GI.Pango.Structs.GlyphItem as Pango.GlyphItem
    import {-# SOURCE #-} qualified GI.Pango.Structs.LayoutLine as Pango.LayoutLine
    import {-# SOURCE #-} qualified GI.Pango.Structs.Rectangle as Pango.Rectangle

    -- | Memory-managed wrapper type.
    newtype LayoutIter = LayoutIter (SP.ManagedPtr LayoutIter)
        deriving (LayoutIter -> LayoutIter -> Bool
    (LayoutIter -> LayoutIter -> Bool)
    -> (LayoutIter -> LayoutIter -> Bool) -> Eq LayoutIter
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: LayoutIter -> LayoutIter -> Bool
    $c/= :: LayoutIter -> LayoutIter -> Bool
    == :: LayoutIter -> LayoutIter -> Bool
    $c== :: LayoutIter -> LayoutIter -> Bool
    Eq)

    instance SP.ManagedPtrNewtype LayoutIter where
        toManagedPtr :: LayoutIter -> ManagedPtr LayoutIter
    toManagedPtr (LayoutIter p :: ManagedPtr LayoutIter
    p) = ManagedPtr LayoutIter
    p

    foreign import ccall "pango_layout_iter_get_type" c_pango_layout_iter_get_type ::
        IO GType

    type instance O.ParentTypes LayoutIter = '[]
    instance O.HasParentTypes LayoutIter

    instance B.Types.TypedObject LayoutIter where
        glibType :: IO GType
    glibType = IO GType
    c_pango_layout_iter_get_type

    instance B.Types.GBoxed LayoutIter

    -- | Convert 'LayoutIter' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
    instance B.GValue.IsGValue LayoutIter where
        toGValue :: LayoutIter -> IO GValue
    toGValue o :: LayoutIter
    o = do
            GType
    gtype <- IO GType
    c_pango_layout_iter_get_type
            LayoutIter -> (Ptr LayoutIter -> IO GValue) -> IO GValue
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    B.ManagedPtr.withManagedPtr LayoutIter
    o (GType
    -> (GValue -> Ptr LayoutIter -> IO ())
    -> Ptr LayoutIter
    -> IO GValue
    forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
    B.GValue.buildGValue GType
    gtype GValue -> Ptr LayoutIter -> IO ()
    forall a. GValue -> Ptr a -> IO ()
    B.GValue.set_boxed)

        fromGValue :: GValue -> IO LayoutIter
    fromGValue gv :: GValue
    gv = do
            Ptr LayoutIter
    ptr <- GValue -> IO (Ptr LayoutIter)
    forall b. GValue -> IO (Ptr b)
    B.GValue.get_boxed GValue
    gv :: IO (Ptr LayoutIter)
            (ManagedPtr LayoutIter -> LayoutIter)
    -> Ptr LayoutIter -> IO LayoutIter
    forall a.
    (HasCallStack, GBoxed a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    B.ManagedPtr.newBoxed ManagedPtr LayoutIter -> LayoutIter
    LayoutIter Ptr LayoutIter
    ptr

    #if defined(ENABLE_OVERLOADING)
    instance O.HasAttributeList LayoutIter
    type instance O.AttributeList LayoutIter = LayoutIterAttributeList
    type LayoutIterAttributeList = ('[ ] :: [(Symbol, *)])
    #endif

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

    foreign import ccall "pango_layout_iter_at_last_line" pango_layout_iter_at_last_line ::
        Ptr LayoutIter ->                       -- iter : TInterface (Name {namespace = "Pango", name = "LayoutIter"})
        IO CInt

    -- | Determines whether /@iter@/ is on the last line of the layout.
    layoutIterAtLastLine ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        LayoutIter
        -- ^ /@iter@/: a t'GI.Pango.Structs.LayoutIter.LayoutIter'
        -> m Bool
        -- ^ __Returns:__ 'P.True' if /@iter@/ is on the last line.
    layoutIterAtLastLine :: LayoutIter -> m Bool
    layoutIterAtLastLine iter :: LayoutIter
    iter = IO Bool -> m Bool
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr LayoutIter
    iter' <- LayoutIter -> IO (Ptr LayoutIter)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr LayoutIter
    iter
        CInt
    result <- Ptr LayoutIter -> IO CInt
    pango_layout_iter_at_last_line Ptr LayoutIter
    iter'
        let result' :: Bool
    result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= 0) CInt
    result
        LayoutIter -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr LayoutIter
    iter
        Bool -> IO Bool
    forall (m :: * -> *) a. Monad m => a -> m a
    return Bool
    result'

    #if defined(ENABLE_OVERLOADING)
    data LayoutIterAtLastLineMethodInfo
    instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo LayoutIterAtLastLineMethodInfo LayoutIter signature where
        overloadedMethod = layoutIterAtLastLine

    #endif

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

    foreign import ccall "pango_layout_iter_copy" pango_layout_iter_copy ::
        Ptr LayoutIter ->                       -- iter : TInterface (Name {namespace = "Pango", name = "LayoutIter"})
        IO (Ptr LayoutIter)

    -- | Copies a t'GI.Pango.Structs.LayoutIter.LayoutIter'.
    --
    -- /Since: 1.20/
    layoutIterCopy ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        LayoutIter
        -- ^ /@iter@/: a t'GI.Pango.Structs.LayoutIter.LayoutIter', may be 'P.Nothing'
        -> m (Maybe LayoutIter)
        -- ^ __Returns:__ the newly allocated t'GI.Pango.Structs.LayoutIter.LayoutIter',
        --               which should be freed with 'GI.Pango.Structs.LayoutIter.layoutIterFree',
        --               or 'P.Nothing' if /@iter@/ was 'P.Nothing'.
    layoutIterCopy :: LayoutIter -> m (Maybe LayoutIter)
    layoutIterCopy iter :: LayoutIter
    iter = IO (Maybe LayoutIter) -> m (Maybe LayoutIter)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe LayoutIter) -> m (Maybe LayoutIter))
    -> IO (Maybe LayoutIter) -> m (Maybe LayoutIter)
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr LayoutIter
    iter' <- LayoutIter -> IO (Ptr LayoutIter)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr LayoutIter
    iter
        Ptr LayoutIter
    result <- Ptr LayoutIter -> IO (Ptr LayoutIter)
    pango_layout_iter_copy Ptr LayoutIter
    iter'
        Maybe LayoutIter
    maybeResult <- Ptr LayoutIter
    -> (Ptr LayoutIter -> IO LayoutIter) -> IO (Maybe LayoutIter)
    forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
    convertIfNonNull Ptr LayoutIter
    result ((Ptr LayoutIter -> IO LayoutIter) -> IO (Maybe LayoutIter))
    -> (Ptr LayoutIter -> IO LayoutIter) -> IO (Maybe LayoutIter)
    forall a b. (a -> b) -> a -> b
    $ \result' :: Ptr LayoutIter
    result' -> do
            LayoutIter
    result'' <- ((ManagedPtr LayoutIter -> LayoutIter)
    -> Ptr LayoutIter -> IO LayoutIter
    forall a.
    (HasCallStack, GBoxed a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    wrapBoxed ManagedPtr LayoutIter -> LayoutIter
    LayoutIter) Ptr LayoutIter
    result'
            LayoutIter -> IO LayoutIter
    forall (m :: * -> *) a. Monad m => a -> m a
    return LayoutIter
    result''
        LayoutIter -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr LayoutIter
    iter
        Maybe LayoutIter -> IO (Maybe LayoutIter)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe LayoutIter
    maybeResult

    #if defined(ENABLE_OVERLOADING)
    data LayoutIterCopyMethodInfo
    instance (signature ~ (m (Maybe LayoutIter)), MonadIO m) => O.MethodInfo LayoutIterCopyMethodInfo LayoutIter signature where
        overloadedMethod = layoutIterCopy

    #endif

    -- method LayoutIter::free
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "iter"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "LayoutIter" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #PangoLayoutIter, may be %NULL"
    --                 , 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_iter_free" pango_layout_iter_free ::
        Ptr LayoutIter ->                       -- iter : TInterface (Name {namespace = "Pango", name = "LayoutIter"})
        IO ()

    -- | Frees an iterator that\'s no longer in use.
    layoutIterFree ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        LayoutIter
        -- ^ /@iter@/: a t'GI.Pango.Structs.LayoutIter.LayoutIter', may be 'P.Nothing'
        -> m ()
    layoutIterFree :: LayoutIter -> m ()
    layoutIterFree iter :: LayoutIter
    iter = IO () -> m ()
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr LayoutIter
    iter' <- LayoutIter -> IO (Ptr LayoutIter)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr LayoutIter
    iter
        Ptr LayoutIter -> IO ()
    pango_layout_iter_free Ptr LayoutIter
    iter'
        LayoutIter -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr LayoutIter
    iter
        () -> IO ()
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    #if defined(ENABLE_OVERLOADING)
    data LayoutIterFreeMethodInfo
    instance (signature ~ (m ()), MonadIO m) => O.MethodInfo LayoutIterFreeMethodInfo LayoutIter signature where
        overloadedMethod = layoutIterFree

    #endif

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

    foreign import ccall "pango_layout_iter_get_baseline" pango_layout_iter_get_baseline ::
        Ptr LayoutIter ->                       -- iter : TInterface (Name {namespace = "Pango", name = "LayoutIter"})
        IO Int32

    -- | Gets the Y position of the current line\'s baseline, in layout
    -- coordinates (origin at top left of the entire layout).
    layoutIterGetBaseline ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        LayoutIter
        -- ^ /@iter@/: a t'GI.Pango.Structs.LayoutIter.LayoutIter'
        -> m Int32
        -- ^ __Returns:__ baseline of current line.
    layoutIterGetBaseline :: LayoutIter -> m Int32
    layoutIterGetBaseline iter :: LayoutIter
    iter = IO Int32 -> m Int32
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr LayoutIter
    iter' <- LayoutIter -> IO (Ptr LayoutIter)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr LayoutIter
    iter
        Int32
    result <- Ptr LayoutIter -> IO Int32
    pango_layout_iter_get_baseline Ptr LayoutIter
    iter'
        LayoutIter -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr LayoutIter
    iter
        Int32 -> IO Int32
    forall (m :: * -> *) a. Monad m => a -> m a
    return Int32
    result

    #if defined(ENABLE_OVERLOADING)
    data LayoutIterGetBaselineMethodInfo
    instance (signature ~ (m Int32), MonadIO m) => O.MethodInfo LayoutIterGetBaselineMethodInfo LayoutIter signature where
        overloadedMethod = layoutIterGetBaseline

    #endif

    -- method LayoutIter::get_char_extents
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "iter"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "LayoutIter" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #PangoLayoutIter" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "logical_rect"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "Rectangle" }
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "rectangle to fill with\n  logical extents"
    --                 , 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_iter_get_char_extents" pango_layout_iter_get_char_extents ::
        Ptr LayoutIter ->                       -- iter : TInterface (Name {namespace = "Pango", name = "LayoutIter"})
        Ptr Pango.Rectangle.Rectangle ->        -- logical_rect : TInterface (Name {namespace = "Pango", name = "Rectangle"})
        IO ()

    -- | Gets the extents of the current character, in layout coordinates
    -- (origin is the top left of the entire layout). Only logical extents
    -- can sensibly be obtained for characters; ink extents make sense only
    -- down to the level of clusters.
    layoutIterGetCharExtents ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        LayoutIter
        -- ^ /@iter@/: a t'GI.Pango.Structs.LayoutIter.LayoutIter'
        -> m (Pango.Rectangle.Rectangle)
    layoutIterGetCharExtents :: LayoutIter -> m Rectangle
    layoutIterGetCharExtents iter :: LayoutIter
    iter = IO Rectangle -> m Rectangle
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Rectangle -> m Rectangle) -> IO Rectangle -> m Rectangle
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr LayoutIter
    iter' <- LayoutIter -> IO (Ptr LayoutIter)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr LayoutIter
    iter
        Ptr Rectangle
    logicalRect <- Int -> IO (Ptr Rectangle)
    forall a. Int -> IO (Ptr a)
    SP.callocBytes 16 :: IO (Ptr Pango.Rectangle.Rectangle)
        Ptr LayoutIter -> Ptr Rectangle -> IO ()
    pango_layout_iter_get_char_extents Ptr LayoutIter
    iter' Ptr Rectangle
    logicalRect
        Rectangle
    logicalRect' <- ((ManagedPtr Rectangle -> Rectangle)
    -> Ptr Rectangle -> IO Rectangle
    forall a.
    (HasCallStack, BoxedPtr a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    wrapPtr ManagedPtr Rectangle -> Rectangle
    Pango.Rectangle.Rectangle) Ptr Rectangle
    logicalRect
        LayoutIter -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr LayoutIter
    iter
        Rectangle -> IO Rectangle
    forall (m :: * -> *) a. Monad m => a -> m a
    return Rectangle
    logicalRect'

    #if defined(ENABLE_OVERLOADING)
    data LayoutIterGetCharExtentsMethodInfo
    instance (signature ~ (m (Pango.Rectangle.Rectangle)), MonadIO m) => O.MethodInfo LayoutIterGetCharExtentsMethodInfo LayoutIter signature where
        overloadedMethod = layoutIterGetCharExtents

    #endif

    -- method LayoutIter::get_cluster_extents
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "iter"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "LayoutIter" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #PangoLayoutIter" , 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 to fill with ink extents, 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 to fill with logical extents, 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_iter_get_cluster_extents" pango_layout_iter_get_cluster_extents ::
        Ptr LayoutIter ->                       -- iter : TInterface (Name {namespace = "Pango", name = "LayoutIter"})
        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 ()

    -- | Gets the extents of the current cluster, in layout coordinates
    -- (origin is the top left of the entire layout).
    layoutIterGetClusterExtents ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        LayoutIter
        -- ^ /@iter@/: a t'GI.Pango.Structs.LayoutIter.LayoutIter'
        -> m ((Pango.Rectangle.Rectangle, Pango.Rectangle.Rectangle))
    layoutIterGetClusterExtents :: LayoutIter -> m (Rectangle, Rectangle)
    layoutIterGetClusterExtents iter :: LayoutIter
    iter = IO (Rectangle, Rectangle) -> m (Rectangle, Rectangle)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Rectangle, Rectangle) -> m (Rectangle, Rectangle))
    -> IO (Rectangle, Rectangle) -> m (Rectangle, Rectangle)
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr LayoutIter
    iter' <- LayoutIter -> IO (Ptr LayoutIter)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr LayoutIter
    iter
        Ptr Rectangle
    inkRect <- Int -> IO (Ptr Rectangle)
    forall a. Int -> IO (Ptr a)
    SP.callocBytes 16 :: IO (Ptr Pango.Rectangle.Rectangle)
        Ptr Rectangle
    logicalRect <- Int -> IO (Ptr Rectangle)
    forall a. Int -> IO (Ptr a)
    SP.callocBytes 16 :: IO (Ptr Pango.Rectangle.Rectangle)
        Ptr LayoutIter -> Ptr Rectangle -> Ptr Rectangle -> IO ()
    pango_layout_iter_get_cluster_extents Ptr LayoutIter
    iter' Ptr Rectangle
    inkRect Ptr Rectangle
    logicalRect
        Rectangle
    inkRect' <- ((ManagedPtr Rectangle -> Rectangle)
    -> Ptr Rectangle -> IO Rectangle
    forall a.
    (HasCallStack, BoxedPtr a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    wrapPtr ManagedPtr Rectangle -> Rectangle
    Pango.Rectangle.Rectangle) Ptr Rectangle
    inkRect
        Rectangle
    logicalRect' <- ((ManagedPtr Rectangle -> Rectangle)
    -> Ptr Rectangle -> IO Rectangle
    forall a.
    (HasCallStack, BoxedPtr a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    wrapPtr ManagedPtr Rectangle -> Rectangle
    Pango.Rectangle.Rectangle) Ptr Rectangle
    logicalRect
        LayoutIter -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr LayoutIter
    iter
        (Rectangle, Rectangle) -> IO (Rectangle, Rectangle)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Rectangle
    inkRect', Rectangle
    logicalRect')

    #if defined(ENABLE_OVERLOADING)
    data LayoutIterGetClusterExtentsMethodInfo
    instance (signature ~ (m ((Pango.Rectangle.Rectangle, Pango.Rectangle.Rectangle))), MonadIO m) => O.MethodInfo LayoutIterGetClusterExtentsMethodInfo LayoutIter signature where
        overloadedMethod = layoutIterGetClusterExtents

    #endif

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

    foreign import ccall "pango_layout_iter_get_index" pango_layout_iter_get_index ::
        Ptr LayoutIter ->                       -- iter : TInterface (Name {namespace = "Pango", name = "LayoutIter"})
        IO Int32

    -- | Gets the current byte index. Note that iterating forward by char
    -- moves in visual order, not logical order, so indexes may not be
    -- sequential. Also, the index may be equal to the length of the text
    -- in the layout, if on the 'P.Nothing' run (see 'GI.Pango.Structs.LayoutIter.layoutIterGetRun').
    layoutIterGetIndex ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        LayoutIter
        -- ^ /@iter@/: a t'GI.Pango.Structs.LayoutIter.LayoutIter'
        -> m Int32
        -- ^ __Returns:__ current byte index.
    layoutIterGetIndex :: LayoutIter -> m Int32
    layoutIterGetIndex iter :: LayoutIter
    iter = IO Int32 -> m Int32
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr LayoutIter
    iter' <- LayoutIter -> IO (Ptr LayoutIter)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr LayoutIter
    iter
        Int32
    result <- Ptr LayoutIter -> IO Int32
    pango_layout_iter_get_index Ptr LayoutIter
    iter'
        LayoutIter -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr LayoutIter
    iter
        Int32 -> IO Int32
    forall (m :: * -> *) a. Monad m => a -> m a
    return Int32
    result

    #if defined(ENABLE_OVERLOADING)
    data LayoutIterGetIndexMethodInfo
    instance (signature ~ (m Int32), MonadIO m) => O.MethodInfo LayoutIterGetIndexMethodInfo LayoutIter signature where
        overloadedMethod = layoutIterGetIndex

    #endif

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

    foreign import ccall "pango_layout_iter_get_layout" pango_layout_iter_get_layout ::
        Ptr LayoutIter ->                       -- iter : TInterface (Name {namespace = "Pango", name = "LayoutIter"})
        IO (Ptr Pango.Layout.Layout)

    -- | Gets the layout associated with a t'GI.Pango.Structs.LayoutIter.LayoutIter'.
    --
    -- /Since: 1.20/
    layoutIterGetLayout ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        LayoutIter
        -- ^ /@iter@/: a t'GI.Pango.Structs.LayoutIter.LayoutIter'
        -> m Pango.Layout.Layout
        -- ^ __Returns:__ the layout associated with /@iter@/.
    layoutIterGetLayout :: LayoutIter -> m Layout
    layoutIterGetLayout iter :: LayoutIter
    iter = IO Layout -> m Layout
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Layout -> m Layout) -> IO Layout -> m Layout
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr LayoutIter
    iter' <- LayoutIter -> IO (Ptr LayoutIter)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr LayoutIter
    iter
        Ptr Layout
    result <- Ptr LayoutIter -> IO (Ptr Layout)
    pango_layout_iter_get_layout Ptr LayoutIter
    iter'
        Text -> Ptr Layout -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL "layoutIterGetLayout" Ptr Layout
    result
        Layout
    result' <- ((ManagedPtr Layout -> Layout) -> Ptr Layout -> IO Layout
    forall a b.
    (HasCallStack, GObject a, GObject b) =>
    (ManagedPtr a -> a) -> Ptr b -> IO a
    newObject ManagedPtr Layout -> Layout
    Pango.Layout.Layout) Ptr Layout
    result
        LayoutIter -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr LayoutIter
    iter
        Layout -> IO Layout
    forall (m :: * -> *) a. Monad m => a -> m a
    return Layout
    result'

    #if defined(ENABLE_OVERLOADING)
    data LayoutIterGetLayoutMethodInfo
    instance (signature ~ (m Pango.Layout.Layout), MonadIO m) => O.MethodInfo LayoutIterGetLayoutMethodInfo LayoutIter signature where
        overloadedMethod = layoutIterGetLayout

    #endif

    -- method LayoutIter::get_layout_extents
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "iter"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "LayoutIter" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #PangoLayoutIter" , 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 to fill with ink extents,\n           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 to fill with logical\n               extents, 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_iter_get_layout_extents" pango_layout_iter_get_layout_extents ::
        Ptr LayoutIter ->                       -- iter : TInterface (Name {namespace = "Pango", name = "LayoutIter"})
        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 ()

    -- | Obtains the extents of the t'GI.Pango.Objects.Layout.Layout' being iterated
    -- over. /@inkRect@/ or /@logicalRect@/ can be 'P.Nothing' if you
    -- aren\'t interested in them.
    layoutIterGetLayoutExtents ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        LayoutIter
        -- ^ /@iter@/: a t'GI.Pango.Structs.LayoutIter.LayoutIter'
        -> m ((Pango.Rectangle.Rectangle, Pango.Rectangle.Rectangle))
    layoutIterGetLayoutExtents :: LayoutIter -> m (Rectangle, Rectangle)
    layoutIterGetLayoutExtents iter :: LayoutIter
    iter = IO (Rectangle, Rectangle) -> m (Rectangle, Rectangle)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Rectangle, Rectangle) -> m (Rectangle, Rectangle))
    -> IO (Rectangle, Rectangle) -> m (Rectangle, Rectangle)
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr LayoutIter
    iter' <- LayoutIter -> IO (Ptr LayoutIter)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr LayoutIter
    iter
        Ptr Rectangle
    inkRect <- Int -> IO (Ptr Rectangle)
    forall a. Int -> IO (Ptr a)
    SP.callocBytes 16 :: IO (Ptr Pango.Rectangle.Rectangle)
        Ptr Rectangle
    logicalRect <- Int -> IO (Ptr Rectangle)
    forall a. Int -> IO (Ptr a)
    SP.callocBytes 16 :: IO (Ptr Pango.Rectangle.Rectangle)
        Ptr LayoutIter -> Ptr Rectangle -> Ptr Rectangle -> IO ()
    pango_layout_iter_get_layout_extents Ptr LayoutIter
    iter' Ptr Rectangle
    inkRect Ptr Rectangle
    logicalRect
        Rectangle
    inkRect' <- ((ManagedPtr Rectangle -> Rectangle)
    -> Ptr Rectangle -> IO Rectangle
    forall a.
    (HasCallStack, BoxedPtr a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    wrapPtr ManagedPtr Rectangle -> Rectangle
    Pango.Rectangle.Rectangle) Ptr Rectangle
    inkRect
        Rectangle
    logicalRect' <- ((ManagedPtr Rectangle -> Rectangle)
    -> Ptr Rectangle -> IO Rectangle
    forall a.
    (HasCallStack, BoxedPtr a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    wrapPtr ManagedPtr Rectangle -> Rectangle
    Pango.Rectangle.Rectangle) Ptr Rectangle
    logicalRect
        LayoutIter -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr LayoutIter
    iter
        (Rectangle, Rectangle) -> IO (Rectangle, Rectangle)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Rectangle
    inkRect', Rectangle
    logicalRect')

    #if defined(ENABLE_OVERLOADING)
    data LayoutIterGetLayoutExtentsMethodInfo
    instance (signature ~ (m ((Pango.Rectangle.Rectangle, Pango.Rectangle.Rectangle))), MonadIO m) => O.MethodInfo LayoutIterGetLayoutExtentsMethodInfo LayoutIter signature where
        overloadedMethod = layoutIterGetLayoutExtents

    #endif

    -- method LayoutIter::get_line
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "iter"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "LayoutIter" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #PangoLayoutIter" , 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_iter_get_line" pango_layout_iter_get_line ::
        Ptr LayoutIter ->                       -- iter : TInterface (Name {namespace = "Pango", name = "LayoutIter"})
        IO (Ptr Pango.LayoutLine.LayoutLine)

    -- | Gets the current line.
    --
    -- Use the faster 'GI.Pango.Structs.LayoutIter.layoutIterGetLineReadonly' if you do not plan
    -- to modify the contents of the line (glyphs, glyph widths, etc.).
    layoutIterGetLine ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        LayoutIter
        -- ^ /@iter@/: a t'GI.Pango.Structs.LayoutIter.LayoutIter'
        -> m Pango.LayoutLine.LayoutLine
        -- ^ __Returns:__ the current line.
    layoutIterGetLine :: LayoutIter -> m LayoutLine
    layoutIterGetLine iter :: LayoutIter
    iter = IO LayoutLine -> m LayoutLine
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO LayoutLine -> m LayoutLine) -> IO LayoutLine -> m LayoutLine
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr LayoutIter
    iter' <- LayoutIter -> IO (Ptr LayoutIter)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr LayoutIter
    iter
        Ptr LayoutLine
    result <- Ptr LayoutIter -> IO (Ptr LayoutLine)
    pango_layout_iter_get_line Ptr LayoutIter
    iter'
        Text -> Ptr LayoutLine -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL "layoutIterGetLine" Ptr LayoutLine
    result
        LayoutLine
    result' <- ((ManagedPtr LayoutLine -> LayoutLine)
    -> Ptr LayoutLine -> IO LayoutLine
    forall a.
    (HasCallStack, GBoxed a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    newBoxed ManagedPtr LayoutLine -> LayoutLine
    Pango.LayoutLine.LayoutLine) Ptr LayoutLine
    result
        LayoutIter -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr LayoutIter
    iter
        LayoutLine -> IO LayoutLine
    forall (m :: * -> *) a. Monad m => a -> m a
    return LayoutLine
    result'

    #if defined(ENABLE_OVERLOADING)
    data LayoutIterGetLineMethodInfo
    instance (signature ~ (m Pango.LayoutLine.LayoutLine), MonadIO m) => O.MethodInfo LayoutIterGetLineMethodInfo LayoutIter signature where
        overloadedMethod = layoutIterGetLine

    #endif

    -- method LayoutIter::get_line_extents
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "iter"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "LayoutIter" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #PangoLayoutIter" , 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 to fill with ink extents, 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 to fill with logical extents, 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_iter_get_line_extents" pango_layout_iter_get_line_extents ::
        Ptr LayoutIter ->                       -- iter : TInterface (Name {namespace = "Pango", name = "LayoutIter"})
        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 ()

    -- | Obtains the extents of the current line. /@inkRect@/ or /@logicalRect@/
    -- can be 'P.Nothing' if you aren\'t interested in them. Extents are in layout
    -- coordinates (origin is the top-left corner of the entire
    -- t'GI.Pango.Objects.Layout.Layout').  Thus the extents returned by this function will be
    -- the same width\/height but not at the same x\/y as the extents
    -- returned from 'GI.Pango.Structs.LayoutLine.layoutLineGetExtents'.
    layoutIterGetLineExtents ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        LayoutIter
        -- ^ /@iter@/: a t'GI.Pango.Structs.LayoutIter.LayoutIter'
        -> m ((Pango.Rectangle.Rectangle, Pango.Rectangle.Rectangle))
    layoutIterGetLineExtents :: LayoutIter -> m (Rectangle, Rectangle)
    layoutIterGetLineExtents iter :: LayoutIter
    iter = IO (Rectangle, Rectangle) -> m (Rectangle, Rectangle)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Rectangle, Rectangle) -> m (Rectangle, Rectangle))
    -> IO (Rectangle, Rectangle) -> m (Rectangle, Rectangle)
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr LayoutIter
    iter' <- LayoutIter -> IO (Ptr LayoutIter)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr LayoutIter
    iter
        Ptr Rectangle
    inkRect <- Int -> IO (Ptr Rectangle)
    forall a. Int -> IO (Ptr a)
    SP.callocBytes 16 :: IO (Ptr Pango.Rectangle.Rectangle)
        Ptr Rectangle
    logicalRect <- Int -> IO (Ptr Rectangle)
    forall a. Int -> IO (Ptr a)
    SP.callocBytes 16 :: IO (Ptr Pango.Rectangle.Rectangle)
        Ptr LayoutIter -> Ptr Rectangle -> Ptr Rectangle -> IO ()
    pango_layout_iter_get_line_extents Ptr LayoutIter
    iter' Ptr Rectangle
    inkRect Ptr Rectangle
    logicalRect
        Rectangle
    inkRect' <- ((ManagedPtr Rectangle -> Rectangle)
    -> Ptr Rectangle -> IO Rectangle
    forall a.
    (HasCallStack, BoxedPtr a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    wrapPtr ManagedPtr Rectangle -> Rectangle
    Pango.Rectangle.Rectangle) Ptr Rectangle
    inkRect
        Rectangle
    logicalRect' <- ((ManagedPtr Rectangle -> Rectangle)
    -> Ptr Rectangle -> IO Rectangle
    forall a.
    (HasCallStack, BoxedPtr a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    wrapPtr ManagedPtr Rectangle -> Rectangle
    Pango.Rectangle.Rectangle) Ptr Rectangle
    logicalRect
        LayoutIter -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr LayoutIter
    iter
        (Rectangle, Rectangle) -> IO (Rectangle, Rectangle)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Rectangle
    inkRect', Rectangle
    logicalRect')

    #if defined(ENABLE_OVERLOADING)
    data LayoutIterGetLineExtentsMethodInfo
    instance (signature ~ (m ((Pango.Rectangle.Rectangle, Pango.Rectangle.Rectangle))), MonadIO m) => O.MethodInfo LayoutIterGetLineExtentsMethodInfo LayoutIter signature where
        overloadedMethod = layoutIterGetLineExtents

    #endif

    -- method LayoutIter::get_line_readonly
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "iter"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "LayoutIter" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #PangoLayoutIter" , 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_iter_get_line_readonly" pango_layout_iter_get_line_readonly ::
        Ptr LayoutIter ->                       -- iter : TInterface (Name {namespace = "Pango", name = "LayoutIter"})
        IO (Ptr Pango.LayoutLine.LayoutLine)

    -- | Gets the current line for read-only access.
    --
    -- This is a faster alternative to 'GI.Pango.Structs.LayoutIter.layoutIterGetLine',
    -- but the user is not expected
    -- to modify the contents of the line (glyphs, glyph widths, etc.).
    --
    -- /Since: 1.16/
    layoutIterGetLineReadonly ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        LayoutIter
        -- ^ /@iter@/: a t'GI.Pango.Structs.LayoutIter.LayoutIter'
        -> m Pango.LayoutLine.LayoutLine
        -- ^ __Returns:__ the current line, that should not be
        -- modified.
    layoutIterGetLineReadonly :: LayoutIter -> m LayoutLine
    layoutIterGetLineReadonly iter :: LayoutIter
    iter = IO LayoutLine -> m LayoutLine
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO LayoutLine -> m LayoutLine) -> IO LayoutLine -> m LayoutLine
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr LayoutIter
    iter' <- LayoutIter -> IO (Ptr LayoutIter)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr LayoutIter
    iter
        Ptr LayoutLine
    result <- Ptr LayoutIter -> IO (Ptr LayoutLine)
    pango_layout_iter_get_line_readonly Ptr LayoutIter
    iter'
        Text -> Ptr LayoutLine -> IO ()
    forall a. HasCallStack => Text -> Ptr a -> IO ()
    checkUnexpectedReturnNULL "layoutIterGetLineReadonly" Ptr LayoutLine
    result
        LayoutLine
    result' <- ((ManagedPtr LayoutLine -> LayoutLine)
    -> Ptr LayoutLine -> IO LayoutLine
    forall a.
    (HasCallStack, GBoxed a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    newBoxed ManagedPtr LayoutLine -> LayoutLine
    Pango.LayoutLine.LayoutLine) Ptr LayoutLine
    result
        LayoutIter -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr LayoutIter
    iter
        LayoutLine -> IO LayoutLine
    forall (m :: * -> *) a. Monad m => a -> m a
    return LayoutLine
    result'

    #if defined(ENABLE_OVERLOADING)
    data LayoutIterGetLineReadonlyMethodInfo
    instance (signature ~ (m Pango.LayoutLine.LayoutLine), MonadIO m) => O.MethodInfo LayoutIterGetLineReadonlyMethodInfo LayoutIter signature where
        overloadedMethod = layoutIterGetLineReadonly

    #endif

    -- method LayoutIter::get_line_yrange
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "iter"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "LayoutIter" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #PangoLayoutIter" , sinceVersion = Nothing }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferNothing
    --           }
    --       , Arg
    --           { argCName = "y0_"
    --           , argType = TBasicType TInt
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "start of line, or %NULL"
    --                 , sinceVersion = Nothing
    --                 }
    --           , argScope = ScopeTypeInvalid
    --           , argClosure = -1
    --           , argDestroy = -1
    --           , argCallerAllocates = False
    --           , transfer = TransferEverything
    --           }
    --       , Arg
    --           { argCName = "y1_"
    --           , argType = TBasicType TInt
    --           , direction = DirectionOut
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "end of line, or %NULL"
    --                 , 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_iter_get_line_yrange" pango_layout_iter_get_line_yrange ::
        Ptr LayoutIter ->                       -- iter : TInterface (Name {namespace = "Pango", name = "LayoutIter"})
        Ptr Int32 ->                            -- y0_ : TBasicType TInt
        Ptr Int32 ->                            -- y1_ : TBasicType TInt
        IO ()

    -- | Divides the vertical space in the t'GI.Pango.Objects.Layout.Layout' being iterated over
    -- between the lines in the layout, and returns the space belonging to
    -- the current line.  A line\'s range includes the line\'s logical
    -- extents, plus half of the spacing above and below the line, if
    -- 'GI.Pango.Objects.Layout.layoutSetSpacing' has been called to set layout spacing.
    -- The Y positions are in layout coordinates (origin at top left of the
    -- entire layout).
    --
    -- Note: Since 1.44, Pango uses line heights for placing lines,
    -- and there may be gaps between the ranges returned by this
    -- function.
    layoutIterGetLineYrange ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        LayoutIter
        -- ^ /@iter@/: a t'GI.Pango.Structs.LayoutIter.LayoutIter'
        -> m ((Int32, Int32))
    layoutIterGetLineYrange :: LayoutIter -> m (Int32, Int32)
    layoutIterGetLineYrange iter :: LayoutIter
    iter = IO (Int32, Int32) -> m (Int32, Int32)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Int32, Int32) -> m (Int32, Int32))
    -> IO (Int32, Int32) -> m (Int32, Int32)
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr LayoutIter
    iter' <- LayoutIter -> IO (Ptr LayoutIter)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr LayoutIter
    iter
        Ptr Int32
    y0_ <- IO (Ptr Int32)
    forall a. Storable a => IO (Ptr a)
    allocMem :: IO (Ptr Int32)
        Ptr Int32
    y1_ <- IO (Ptr Int32)
    forall a. Storable a => IO (Ptr a)
    allocMem :: IO (Ptr Int32)
        Ptr LayoutIter -> Ptr Int32 -> Ptr Int32 -> IO ()
    pango_layout_iter_get_line_yrange Ptr LayoutIter
    iter' Ptr Int32
    y0_ Ptr Int32
    y1_
        Int32
    y0_' <- Ptr Int32 -> IO Int32
    forall a. Storable a => Ptr a -> IO a
    peek Ptr Int32
    y0_
        Int32
    y1_' <- Ptr Int32 -> IO Int32
    forall a. Storable a => Ptr a -> IO a
    peek Ptr Int32
    y1_
        LayoutIter -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr LayoutIter
    iter
        Ptr Int32 -> IO ()
    forall a. Ptr a -> IO ()
    freeMem Ptr Int32
    y0_
        Ptr Int32 -> IO ()
    forall a. Ptr a -> IO ()
    freeMem Ptr Int32
    y1_
        (Int32, Int32) -> IO (Int32, Int32)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int32
    y0_', Int32
    y1_')

    #if defined(ENABLE_OVERLOADING)
    data LayoutIterGetLineYrangeMethodInfo
    instance (signature ~ (m ((Int32, Int32))), MonadIO m) => O.MethodInfo LayoutIterGetLineYrangeMethodInfo LayoutIter signature where
        overloadedMethod = layoutIterGetLineYrange

    #endif

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

    foreign import ccall "pango_layout_iter_get_run" pango_layout_iter_get_run ::
        Ptr LayoutIter ->                       -- iter : TInterface (Name {namespace = "Pango", name = "LayoutIter"})
        IO (Ptr Pango.GlyphItem.GlyphItem)

    -- | Gets the current run. When iterating by run, at the end of each
    -- line, there\'s a position with a 'P.Nothing' run, so this function can return
    -- 'P.Nothing'. The 'P.Nothing' run at the end of each line ensures that all lines have
    -- at least one run, even lines consisting of only a newline.
    --
    -- Use the faster 'GI.Pango.Structs.LayoutIter.layoutIterGetRunReadonly' if you do not plan
    -- to modify the contents of the run (glyphs, glyph widths, etc.).
    layoutIterGetRun ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        LayoutIter
        -- ^ /@iter@/: a t'GI.Pango.Structs.LayoutIter.LayoutIter'
        -> m (Maybe Pango.GlyphItem.GlyphItem)
        -- ^ __Returns:__ the current run.
    layoutIterGetRun :: LayoutIter -> m (Maybe GlyphItem)
    layoutIterGetRun iter :: LayoutIter
    iter = IO (Maybe GlyphItem) -> m (Maybe GlyphItem)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe GlyphItem) -> m (Maybe GlyphItem))
    -> IO (Maybe GlyphItem) -> m (Maybe GlyphItem)
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr LayoutIter
    iter' <- LayoutIter -> IO (Ptr LayoutIter)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr LayoutIter
    iter
        Ptr GlyphItem
    result <- Ptr LayoutIter -> IO (Ptr GlyphItem)
    pango_layout_iter_get_run Ptr LayoutIter
    iter'
        Maybe GlyphItem
    maybeResult <- Ptr GlyphItem
    -> (Ptr GlyphItem -> IO GlyphItem) -> IO (Maybe GlyphItem)
    forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
    convertIfNonNull Ptr GlyphItem
    result ((Ptr GlyphItem -> IO GlyphItem) -> IO (Maybe GlyphItem))
    -> (Ptr GlyphItem -> IO GlyphItem) -> IO (Maybe GlyphItem)
    forall a b. (a -> b) -> a -> b
    $ \result' :: Ptr GlyphItem
    result' -> do
            GlyphItem
    result'' <- ((ManagedPtr GlyphItem -> GlyphItem)
    -> Ptr GlyphItem -> IO GlyphItem
    forall a.
    (HasCallStack, GBoxed a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    newBoxed ManagedPtr GlyphItem -> GlyphItem
    Pango.GlyphItem.GlyphItem) Ptr GlyphItem
    result'
            GlyphItem -> IO GlyphItem
    forall (m :: * -> *) a. Monad m => a -> m a
    return GlyphItem
    result''
        LayoutIter -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr LayoutIter
    iter
        Maybe GlyphItem -> IO (Maybe GlyphItem)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe GlyphItem
    maybeResult

    #if defined(ENABLE_OVERLOADING)
    data LayoutIterGetRunMethodInfo
    instance (signature ~ (m (Maybe Pango.GlyphItem.GlyphItem)), MonadIO m) => O.MethodInfo LayoutIterGetRunMethodInfo LayoutIter signature where
        overloadedMethod = layoutIterGetRun

    #endif

    -- method LayoutIter::get_run_extents
    -- method type : OrdinaryMethod
    -- Args: [ Arg
    --           { argCName = "iter"
    --           , argType =
    --               TInterface Name { namespace = "Pango" , name = "LayoutIter" }
    --           , direction = DirectionIn
    --           , mayBeNull = False
    --           , argDoc =
    --               Documentation
    --                 { rawDocText = Just "a #PangoLayoutIter" , 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 to fill with ink extents, 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 to fill with logical extents, 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_iter_get_run_extents" pango_layout_iter_get_run_extents ::
        Ptr LayoutIter ->                       -- iter : TInterface (Name {namespace = "Pango", name = "LayoutIter"})
        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 ()

    -- | Gets the extents of the current run in layout coordinates
    -- (origin is the top left of the entire layout).
    layoutIterGetRunExtents ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        LayoutIter
        -- ^ /@iter@/: a t'GI.Pango.Structs.LayoutIter.LayoutIter'
        -> m ((Pango.Rectangle.Rectangle, Pango.Rectangle.Rectangle))
    layoutIterGetRunExtents :: LayoutIter -> m (Rectangle, Rectangle)
    layoutIterGetRunExtents iter :: LayoutIter
    iter = IO (Rectangle, Rectangle) -> m (Rectangle, Rectangle)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Rectangle, Rectangle) -> m (Rectangle, Rectangle))
    -> IO (Rectangle, Rectangle) -> m (Rectangle, Rectangle)
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr LayoutIter
    iter' <- LayoutIter -> IO (Ptr LayoutIter)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr LayoutIter
    iter
        Ptr Rectangle
    inkRect <- Int -> IO (Ptr Rectangle)
    forall a. Int -> IO (Ptr a)
    SP.callocBytes 16 :: IO (Ptr Pango.Rectangle.Rectangle)
        Ptr Rectangle
    logicalRect <- Int -> IO (Ptr Rectangle)
    forall a. Int -> IO (Ptr a)
    SP.callocBytes 16 :: IO (Ptr Pango.Rectangle.Rectangle)
        Ptr LayoutIter -> Ptr Rectangle -> Ptr Rectangle -> IO ()
    pango_layout_iter_get_run_extents Ptr LayoutIter
    iter' Ptr Rectangle
    inkRect Ptr Rectangle
    logicalRect
        Rectangle
    inkRect' <- ((ManagedPtr Rectangle -> Rectangle)
    -> Ptr Rectangle -> IO Rectangle
    forall a.
    (HasCallStack, BoxedPtr a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    wrapPtr ManagedPtr Rectangle -> Rectangle
    Pango.Rectangle.Rectangle) Ptr Rectangle
    inkRect
        Rectangle
    logicalRect' <- ((ManagedPtr Rectangle -> Rectangle)
    -> Ptr Rectangle -> IO Rectangle
    forall a.
    (HasCallStack, BoxedPtr a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    wrapPtr ManagedPtr Rectangle -> Rectangle
    Pango.Rectangle.Rectangle) Ptr Rectangle
    logicalRect
        LayoutIter -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr LayoutIter
    iter
        (Rectangle, Rectangle) -> IO (Rectangle, Rectangle)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Rectangle
    inkRect', Rectangle
    logicalRect')

    #if defined(ENABLE_OVERLOADING)
    data LayoutIterGetRunExtentsMethodInfo
    instance (signature ~ (m ((Pango.Rectangle.Rectangle, Pango.Rectangle.Rectangle))), MonadIO m) => O.MethodInfo LayoutIterGetRunExtentsMethodInfo LayoutIter signature where
        overloadedMethod = layoutIterGetRunExtents

    #endif

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

    foreign import ccall "pango_layout_iter_get_run_readonly" pango_layout_iter_get_run_readonly ::
        Ptr LayoutIter ->                       -- iter : TInterface (Name {namespace = "Pango", name = "LayoutIter"})
        IO (Ptr Pango.GlyphItem.GlyphItem)

    -- | Gets the current run. When iterating by run, at the end of each
    -- line, there\'s a position with a 'P.Nothing' run, so this function can return
    -- 'P.Nothing'. The 'P.Nothing' run at the end of each line ensures that all lines have
    -- at least one run, even lines consisting of only a newline.
    --
    -- This is a faster alternative to 'GI.Pango.Structs.LayoutIter.layoutIterGetRun',
    -- but the user is not expected
    -- to modify the contents of the run (glyphs, glyph widths, etc.).
    --
    -- /Since: 1.16/
    layoutIterGetRunReadonly ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        LayoutIter
        -- ^ /@iter@/: a t'GI.Pango.Structs.LayoutIter.LayoutIter'
        -> m (Maybe Pango.GlyphItem.GlyphItem)
        -- ^ __Returns:__ the current run, that
        -- should not be modified.
    layoutIterGetRunReadonly :: LayoutIter -> m (Maybe GlyphItem)
    layoutIterGetRunReadonly iter :: LayoutIter
    iter = IO (Maybe GlyphItem) -> m (Maybe GlyphItem)
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO (Maybe GlyphItem) -> m (Maybe GlyphItem))
    -> IO (Maybe GlyphItem) -> m (Maybe GlyphItem)
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr LayoutIter
    iter' <- LayoutIter -> IO (Ptr LayoutIter)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr LayoutIter
    iter
        Ptr GlyphItem
    result <- Ptr LayoutIter -> IO (Ptr GlyphItem)
    pango_layout_iter_get_run_readonly Ptr LayoutIter
    iter'
        Maybe GlyphItem
    maybeResult <- Ptr GlyphItem
    -> (Ptr GlyphItem -> IO GlyphItem) -> IO (Maybe GlyphItem)
    forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
    convertIfNonNull Ptr GlyphItem
    result ((Ptr GlyphItem -> IO GlyphItem) -> IO (Maybe GlyphItem))
    -> (Ptr GlyphItem -> IO GlyphItem) -> IO (Maybe GlyphItem)
    forall a b. (a -> b) -> a -> b
    $ \result' :: Ptr GlyphItem
    result' -> do
            GlyphItem
    result'' <- ((ManagedPtr GlyphItem -> GlyphItem)
    -> Ptr GlyphItem -> IO GlyphItem
    forall a.
    (HasCallStack, GBoxed a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    newBoxed ManagedPtr GlyphItem -> GlyphItem
    Pango.GlyphItem.GlyphItem) Ptr GlyphItem
    result'
            GlyphItem -> IO GlyphItem
    forall (m :: * -> *) a. Monad m => a -> m a
    return GlyphItem
    result''
        LayoutIter -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr LayoutIter
    iter
        Maybe GlyphItem -> IO (Maybe GlyphItem)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe GlyphItem
    maybeResult

    #if defined(ENABLE_OVERLOADING)
    data LayoutIterGetRunReadonlyMethodInfo
    instance (signature ~ (m (Maybe Pango.GlyphItem.GlyphItem)), MonadIO m) => O.MethodInfo LayoutIterGetRunReadonlyMethodInfo LayoutIter signature where
        overloadedMethod = layoutIterGetRunReadonly

    #endif

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

    foreign import ccall "pango_layout_iter_next_char" pango_layout_iter_next_char ::
        Ptr LayoutIter ->                       -- iter : TInterface (Name {namespace = "Pango", name = "LayoutIter"})
        IO CInt

    -- | Moves /@iter@/ forward to the next character in visual order. If /@iter@/ was already at
    -- the end of the layout, returns 'P.False'.
    layoutIterNextChar ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        LayoutIter
        -- ^ /@iter@/: a t'GI.Pango.Structs.LayoutIter.LayoutIter'
        -> m Bool
        -- ^ __Returns:__ whether motion was possible.
    layoutIterNextChar :: LayoutIter -> m Bool
    layoutIterNextChar iter :: LayoutIter
    iter = IO Bool -> m Bool
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr LayoutIter
    iter' <- LayoutIter -> IO (Ptr LayoutIter)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr LayoutIter
    iter
        CInt
    result <- Ptr LayoutIter -> IO CInt
    pango_layout_iter_next_char Ptr LayoutIter
    iter'
        let result' :: Bool
    result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= 0) CInt
    result
        LayoutIter -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr LayoutIter
    iter
        Bool -> IO Bool
    forall (m :: * -> *) a. Monad m => a -> m a
    return Bool
    result'

    #if defined(ENABLE_OVERLOADING)
    data LayoutIterNextCharMethodInfo
    instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo LayoutIterNextCharMethodInfo LayoutIter signature where
        overloadedMethod = layoutIterNextChar

    #endif

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

    foreign import ccall "pango_layout_iter_next_cluster" pango_layout_iter_next_cluster ::
        Ptr LayoutIter ->                       -- iter : TInterface (Name {namespace = "Pango", name = "LayoutIter"})
        IO CInt

    -- | Moves /@iter@/ forward to the next cluster in visual order. If /@iter@/
    -- was already at the end of the layout, returns 'P.False'.
    layoutIterNextCluster ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        LayoutIter
        -- ^ /@iter@/: a t'GI.Pango.Structs.LayoutIter.LayoutIter'
        -> m Bool
        -- ^ __Returns:__ whether motion was possible.
    layoutIterNextCluster :: LayoutIter -> m Bool
    layoutIterNextCluster iter :: LayoutIter
    iter = IO Bool -> m Bool
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr LayoutIter
    iter' <- LayoutIter -> IO (Ptr LayoutIter)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr LayoutIter
    iter
        CInt
    result <- Ptr LayoutIter -> IO CInt
    pango_layout_iter_next_cluster Ptr LayoutIter
    iter'
        let result' :: Bool
    result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= 0) CInt
    result
        LayoutIter -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr LayoutIter
    iter
        Bool -> IO Bool
    forall (m :: * -> *) a. Monad m => a -> m a
    return Bool
    result'

    #if defined(ENABLE_OVERLOADING)
    data LayoutIterNextClusterMethodInfo
    instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo LayoutIterNextClusterMethodInfo LayoutIter signature where
        overloadedMethod = layoutIterNextCluster

    #endif

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

    foreign import ccall "pango_layout_iter_next_line" pango_layout_iter_next_line ::
        Ptr LayoutIter ->                       -- iter : TInterface (Name {namespace = "Pango", name = "LayoutIter"})
        IO CInt

    -- | Moves /@iter@/ forward to the start of the next line. If /@iter@/ is
    -- already on the last line, returns 'P.False'.
    layoutIterNextLine ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        LayoutIter
        -- ^ /@iter@/: a t'GI.Pango.Structs.LayoutIter.LayoutIter'
        -> m Bool
        -- ^ __Returns:__ whether motion was possible.
    layoutIterNextLine :: LayoutIter -> m Bool
    layoutIterNextLine iter :: LayoutIter
    iter = IO Bool -> m Bool
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr LayoutIter
    iter' <- LayoutIter -> IO (Ptr LayoutIter)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr LayoutIter
    iter
        CInt
    result <- Ptr LayoutIter -> IO CInt
    pango_layout_iter_next_line Ptr LayoutIter
    iter'
        let result' :: Bool
    result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= 0) CInt
    result
        LayoutIter -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr LayoutIter
    iter
        Bool -> IO Bool
    forall (m :: * -> *) a. Monad m => a -> m a
    return Bool
    result'

    #if defined(ENABLE_OVERLOADING)
    data LayoutIterNextLineMethodInfo
    instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo LayoutIterNextLineMethodInfo LayoutIter signature where
        overloadedMethod = layoutIterNextLine

    #endif

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

    foreign import ccall "pango_layout_iter_next_run" pango_layout_iter_next_run ::
        Ptr LayoutIter ->                       -- iter : TInterface (Name {namespace = "Pango", name = "LayoutIter"})
        IO CInt

    -- | Moves /@iter@/ forward to the next run in visual order. If /@iter@/ was
    -- already at the end of the layout, returns 'P.False'.
    layoutIterNextRun ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        LayoutIter
        -- ^ /@iter@/: a t'GI.Pango.Structs.LayoutIter.LayoutIter'
        -> m Bool
        -- ^ __Returns:__ whether motion was possible.
    layoutIterNextRun :: LayoutIter -> m Bool
    layoutIterNextRun iter :: LayoutIter
    iter = IO Bool -> m Bool
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
    forall a b. (a -> b) -> a -> b
    $ do
        Ptr LayoutIter
    iter' <- LayoutIter -> IO (Ptr LayoutIter)
    forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
    unsafeManagedPtrGetPtr LayoutIter
    iter
        CInt
    result <- Ptr LayoutIter -> IO CInt
    pango_layout_iter_next_run Ptr LayoutIter
    iter'
        let result' :: Bool
    result' = (CInt -> CInt -> Bool
    forall a. Eq a => a -> a -> Bool
    /= 0) CInt
    result
        LayoutIter -> IO ()
    forall a. ManagedPtrNewtype a => a -> IO ()
    touchManagedPtr LayoutIter
    iter
        Bool -> IO Bool
    forall (m :: * -> *) a. Monad m => a -> m a
    return Bool
    result'

    #if defined(ENABLE_OVERLOADING)
    data LayoutIterNextRunMethodInfo
    instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo LayoutIterNextRunMethodInfo LayoutIter signature where
        overloadedMethod = layoutIterNextRun

    #endif

    #if defined(ENABLE_OVERLOADING)
    type family ResolveLayoutIterMethod (t :: Symbol) (o :: *) :: * where
        ResolveLayoutIterMethod "atLastLine" o = LayoutIterAtLastLineMethodInfo
        ResolveLayoutIterMethod "copy" o = LayoutIterCopyMethodInfo
        ResolveLayoutIterMethod "free" o = LayoutIterFreeMethodInfo
        ResolveLayoutIterMethod "nextChar" o = LayoutIterNextCharMethodInfo
        ResolveLayoutIterMethod "nextCluster" o = LayoutIterNextClusterMethodInfo
        ResolveLayoutIterMethod "nextLine" o = LayoutIterNextLineMethodInfo
        ResolveLayoutIterMethod "nextRun" o = LayoutIterNextRunMethodInfo
        ResolveLayoutIterMethod "getBaseline" o = LayoutIterGetBaselineMethodInfo
        ResolveLayoutIterMethod "getCharExtents" o = LayoutIterGetCharExtentsMethodInfo
        ResolveLayoutIterMethod "getClusterExtents" o = LayoutIterGetClusterExtentsMethodInfo
        ResolveLayoutIterMethod "getIndex" o = LayoutIterGetIndexMethodInfo
        ResolveLayoutIterMethod "getLayout" o = LayoutIterGetLayoutMethodInfo
        ResolveLayoutIterMethod "getLayoutExtents" o = LayoutIterGetLayoutExtentsMethodInfo
        ResolveLayoutIterMethod "getLine" o = LayoutIterGetLineMethodInfo
        ResolveLayoutIterMethod "getLineExtents" o = LayoutIterGetLineExtentsMethodInfo
        ResolveLayoutIterMethod "getLineReadonly" o = LayoutIterGetLineReadonlyMethodInfo
        ResolveLayoutIterMethod "getLineYrange" o = LayoutIterGetLineYrangeMethodInfo
        ResolveLayoutIterMethod "getRun" o = LayoutIterGetRunMethodInfo
        ResolveLayoutIterMethod "getRunExtents" o = LayoutIterGetRunExtentsMethodInfo
        ResolveLayoutIterMethod "getRunReadonly" o = LayoutIterGetRunReadonlyMethodInfo
        ResolveLayoutIterMethod l o = O.MethodResolutionFailed l o

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

    #endif