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

    A 'GI.Pango.Structs.GlyphItemIter.GlyphItemIter' is an iterator over the clusters in a
    'GI.Pango.Structs.GlyphItem.GlyphItem'.  The \<firstterm>forward direction\<\/firstterm> of the
    iterator is the logical direction of text.  That is, with increasing
    /@startIndex@/ and /@startChar@/ values.  If /@glyphItem@/ is right-to-left
    (that is, if \<literal>/@glyphItem@/->item->analysis.level\<\/literal> is odd),
    then /@startGlyph@/ decreases as the iterator moves forward.  Moreover,
    in right-to-left cases, /@startGlyph@/ is greater than /@endGlyph@/.

    An iterator should be initialized using either of
    'GI.Pango.Structs.GlyphItemIter.glyphItemIterInitStart' and
    'GI.Pango.Structs.GlyphItemIter.glyphItemIterInitEnd', for forward and backward iteration
    respectively, and walked over using any desired mixture of
    'GI.Pango.Structs.GlyphItemIter.glyphItemIterNextCluster' and
    'GI.Pango.Structs.GlyphItemIter.glyphItemIterPrevCluster'.  A common idiom for doing a
    forward iteration over the clusters is:
    \<programlisting>
    PangoGlyphItemIter cluster_iter;
    gboolean have_cluster;

    for (have_cluster = pango_glyph_item_iter_init_start (&amp;cluster_iter,
                                                          glyph_item, text);
         have_cluster;
         have_cluster = pango_glyph_item_iter_next_cluster (&amp;cluster_iter))
    {
      ...
    }
    \<\/programlisting>

    Note that /@text@/ is the start of the text for layout, which is then
    indexed by \<literal>/@glyphItem@/->item->offset\<\/literal> to get to the
    text of /@glyphItem@/.  The /@startIndex@/ and /@endIndex@/ values can directly
    index into /@text@/.  The /@startGlyph@/, /@endGlyph@/, /@startChar@/, and /@endChar@/
    values however are zero-based for the /@glyphItem@/.  For each cluster, the
    item pointed at by the start variables is included in the cluster while
    the one pointed at by end variables is not.

    None of the members of a 'GI.Pango.Structs.GlyphItemIter.GlyphItemIter' should be modified manually.

    /Since: 1.22/
    -}

    #define ENABLE_OVERLOADING \
           (!defined(__HADDOCK_VERSION__))

    module GI.Pango.Structs.GlyphItemIter
        (

    -- * Exported types
        GlyphItemIter(..)                       ,
        newZeroGlyphItemIter                    ,
        noGlyphItemIter                         ,

     -- * Methods
    -- ** copy #method:copy#

    #if ENABLE_OVERLOADING
        GlyphItemIterCopyMethodInfo             ,
    #endif
        glyphItemIterCopy                       ,

    -- ** free #method:free#

    #if ENABLE_OVERLOADING
        GlyphItemIterFreeMethodInfo             ,
    #endif
        glyphItemIterFree                       ,

    -- ** initEnd #method:initEnd#

    #if ENABLE_OVERLOADING
        GlyphItemIterInitEndMethodInfo          ,
    #endif
        glyphItemIterInitEnd                    ,

    -- ** initStart #method:initStart#

    #if ENABLE_OVERLOADING
        GlyphItemIterInitStartMethodInfo        ,
    #endif
        glyphItemIterInitStart                  ,

    -- ** nextCluster #method:nextCluster#

    #if ENABLE_OVERLOADING
        GlyphItemIterNextClusterMethodInfo      ,
    #endif
        glyphItemIterNextCluster                ,

    -- ** prevCluster #method:prevCluster#

    #if ENABLE_OVERLOADING
        GlyphItemIterPrevClusterMethodInfo      ,
    #endif
        glyphItemIterPrevCluster                ,

     -- * Properties
    -- ** endChar #attr:endChar#
    {- | /No description available in the introspection data./
    -}
        getGlyphItemIterEndChar                 ,
    #if ENABLE_OVERLOADING
        glyphItemIter_endChar                   ,
    #endif
        setGlyphItemIterEndChar                 ,

    -- ** endGlyph #attr:endGlyph#
    {- | /No description available in the introspection data./
    -}
        getGlyphItemIterEndGlyph                ,
    #if ENABLE_OVERLOADING
        glyphItemIter_endGlyph                  ,
    #endif
        setGlyphItemIterEndGlyph                ,

    -- ** endIndex #attr:endIndex#
    {- | /No description available in the introspection data./
    -}
        getGlyphItemIterEndIndex                ,
    #if ENABLE_OVERLOADING
        glyphItemIter_endIndex                  ,
    #endif
        setGlyphItemIterEndIndex                ,

    -- ** glyphItem #attr:glyphItem#
    {- | /No description available in the introspection data./
    -}
        clearGlyphItemIterGlyphItem             ,
        getGlyphItemIterGlyphItem               ,
    #if ENABLE_OVERLOADING
        glyphItemIter_glyphItem                 ,
    #endif
        setGlyphItemIterGlyphItem               ,

    -- ** startChar #attr:startChar#
    {- | /No description available in the introspection data./
    -}
        getGlyphItemIterStartChar               ,
    #if ENABLE_OVERLOADING
        glyphItemIter_startChar                 ,
    #endif
        setGlyphItemIterStartChar               ,

    -- ** startGlyph #attr:startGlyph#
    {- | /No description available in the introspection data./
    -}
        getGlyphItemIterStartGlyph              ,
    #if ENABLE_OVERLOADING
        glyphItemIter_startGlyph                ,
    #endif
        setGlyphItemIterStartGlyph              ,

    -- ** startIndex #attr:startIndex#
    {- | /No description available in the introspection data./
    -}
        getGlyphItemIterStartIndex              ,
    #if ENABLE_OVERLOADING
        glyphItemIter_startIndex                ,
    #endif
        setGlyphItemIterStartIndex              ,

    -- ** text #attr:text#
    {- | /No description available in the introspection data./
    -}
        clearGlyphItemIterText                  ,
        getGlyphItemIterText                    ,
    #if ENABLE_OVERLOADING
        glyphItemIter_text                      ,
    #endif
        setGlyphItemIterText                    ,

        ) 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.Structs.GlyphItem as Pango.GlyphItem

    -- | Memory-managed wrapper type.
    newtype GlyphItemIter = GlyphItemIter (ManagedPtr GlyphItemIter)
    foreign import ccall "pango_glyph_item_iter_get_type" c_pango_glyph_item_iter_get_type ::
        IO GType

    instance BoxedObject GlyphItemIter where
        boxedType _ = c_pango_glyph_item_iter_get_type

    -- | Construct a `GlyphItemIter` struct initialized to zero.
    newZeroGlyphItemIter :: MonadIO m => m GlyphItemIter
    newZeroGlyphItemIter = liftIO $ callocBoxedBytes 40 >>= wrapBoxed GlyphItemIter

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

    -- | A convenience alias for `Nothing` :: `Maybe` `GlyphItemIter`.
    noGlyphItemIter :: Maybe GlyphItemIter
    noGlyphItemIter = Nothing

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

    @
    'Data.GI.Base.Attributes.get' glyphItemIter #glyphItem
    @
    -}
    getGlyphItemIterGlyphItem :: MonadIO m => GlyphItemIter -> m (Maybe Pango.GlyphItem.GlyphItem)
    getGlyphItemIterGlyphItem s = liftIO $ withManagedPtr s $ \ptr -> do
        val <- peek (ptr `plusPtr` 0) :: IO (Ptr Pango.GlyphItem.GlyphItem)
        result <- SP.convertIfNonNull val $ \val' -> do
            val'' <- (newBoxed Pango.GlyphItem.GlyphItem) val'
            return val''
        return result

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

    @
    'Data.GI.Base.Attributes.set' glyphItemIter [ #glyphItem 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setGlyphItemIterGlyphItem :: MonadIO m => GlyphItemIter -> Ptr Pango.GlyphItem.GlyphItem -> m ()
    setGlyphItemIterGlyphItem s val = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 0) (val :: Ptr Pango.GlyphItem.GlyphItem)

    {- |
    Set the value of the “@glyph_item@” 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' #glyphItem
    @
    -}
    clearGlyphItemIterGlyphItem :: MonadIO m => GlyphItemIter -> m ()
    clearGlyphItemIterGlyphItem s = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 0) (FP.nullPtr :: Ptr Pango.GlyphItem.GlyphItem)

    #if ENABLE_OVERLOADING
    data GlyphItemIterGlyphItemFieldInfo
    instance AttrInfo GlyphItemIterGlyphItemFieldInfo where
        type AttrAllowedOps GlyphItemIterGlyphItemFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint GlyphItemIterGlyphItemFieldInfo = (~) (Ptr Pango.GlyphItem.GlyphItem)
        type AttrBaseTypeConstraint GlyphItemIterGlyphItemFieldInfo = (~) GlyphItemIter
        type AttrGetType GlyphItemIterGlyphItemFieldInfo = Maybe Pango.GlyphItem.GlyphItem
        type AttrLabel GlyphItemIterGlyphItemFieldInfo = "glyph_item"
        type AttrOrigin GlyphItemIterGlyphItemFieldInfo = GlyphItemIter
        attrGet _ = getGlyphItemIterGlyphItem
        attrSet _ = setGlyphItemIterGlyphItem
        attrConstruct = undefined
        attrClear _ = clearGlyphItemIterGlyphItem

    glyphItemIter_glyphItem :: AttrLabelProxy "glyphItem"
    glyphItemIter_glyphItem = AttrLabelProxy

    #endif

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

    @
    'Data.GI.Base.Attributes.get' glyphItemIter #text
    @
    -}
    getGlyphItemIterText :: MonadIO m => GlyphItemIter -> m (Maybe T.Text)
    getGlyphItemIterText s = liftIO $ withManagedPtr s $ \ptr -> do
        val <- peek (ptr `plusPtr` 8) :: IO CString
        result <- SP.convertIfNonNull val $ \val' -> do
            val'' <- cstringToText val'
            return val''
        return result

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

    @
    'Data.GI.Base.Attributes.set' glyphItemIter [ #text 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setGlyphItemIterText :: MonadIO m => GlyphItemIter -> CString -> m ()
    setGlyphItemIterText s val = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 8) (val :: CString)

    {- |
    Set the value of the “@text@” 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' #text
    @
    -}
    clearGlyphItemIterText :: MonadIO m => GlyphItemIter -> m ()
    clearGlyphItemIterText s = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 8) (FP.nullPtr :: CString)

    #if ENABLE_OVERLOADING
    data GlyphItemIterTextFieldInfo
    instance AttrInfo GlyphItemIterTextFieldInfo where
        type AttrAllowedOps GlyphItemIterTextFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint GlyphItemIterTextFieldInfo = (~) CString
        type AttrBaseTypeConstraint GlyphItemIterTextFieldInfo = (~) GlyphItemIter
        type AttrGetType GlyphItemIterTextFieldInfo = Maybe T.Text
        type AttrLabel GlyphItemIterTextFieldInfo = "text"
        type AttrOrigin GlyphItemIterTextFieldInfo = GlyphItemIter
        attrGet _ = getGlyphItemIterText
        attrSet _ = setGlyphItemIterText
        attrConstruct = undefined
        attrClear _ = clearGlyphItemIterText

    glyphItemIter_text :: AttrLabelProxy "text"
    glyphItemIter_text = AttrLabelProxy

    #endif

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

    @
    'Data.GI.Base.Attributes.get' glyphItemIter #startGlyph
    @
    -}
    getGlyphItemIterStartGlyph :: MonadIO m => GlyphItemIter -> m Int32
    getGlyphItemIterStartGlyph s = liftIO $ withManagedPtr s $ \ptr -> do
        val <- peek (ptr `plusPtr` 16) :: IO Int32
        return val

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

    @
    'Data.GI.Base.Attributes.set' glyphItemIter [ #startGlyph 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setGlyphItemIterStartGlyph :: MonadIO m => GlyphItemIter -> Int32 -> m ()
    setGlyphItemIterStartGlyph s val = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 16) (val :: Int32)

    #if ENABLE_OVERLOADING
    data GlyphItemIterStartGlyphFieldInfo
    instance AttrInfo GlyphItemIterStartGlyphFieldInfo where
        type AttrAllowedOps GlyphItemIterStartGlyphFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint GlyphItemIterStartGlyphFieldInfo = (~) Int32
        type AttrBaseTypeConstraint GlyphItemIterStartGlyphFieldInfo = (~) GlyphItemIter
        type AttrGetType GlyphItemIterStartGlyphFieldInfo = Int32
        type AttrLabel GlyphItemIterStartGlyphFieldInfo = "start_glyph"
        type AttrOrigin GlyphItemIterStartGlyphFieldInfo = GlyphItemIter
        attrGet _ = getGlyphItemIterStartGlyph
        attrSet _ = setGlyphItemIterStartGlyph
        attrConstruct = undefined
        attrClear _ = undefined

    glyphItemIter_startGlyph :: AttrLabelProxy "startGlyph"
    glyphItemIter_startGlyph = 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' glyphItemIter #startIndex
    @
    -}
    getGlyphItemIterStartIndex :: MonadIO m => GlyphItemIter -> m Int32
    getGlyphItemIterStartIndex s = liftIO $ withManagedPtr s $ \ptr -> do
        val <- peek (ptr `plusPtr` 20) :: 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' glyphItemIter [ #startIndex 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setGlyphItemIterStartIndex :: MonadIO m => GlyphItemIter -> Int32 -> m ()
    setGlyphItemIterStartIndex s val = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 20) (val :: Int32)

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

    glyphItemIter_startIndex :: AttrLabelProxy "startIndex"
    glyphItemIter_startIndex = AttrLabelProxy

    #endif

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

    @
    'Data.GI.Base.Attributes.get' glyphItemIter #startChar
    @
    -}
    getGlyphItemIterStartChar :: MonadIO m => GlyphItemIter -> m Int32
    getGlyphItemIterStartChar s = liftIO $ withManagedPtr s $ \ptr -> do
        val <- peek (ptr `plusPtr` 24) :: IO Int32
        return val

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

    @
    'Data.GI.Base.Attributes.set' glyphItemIter [ #startChar 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setGlyphItemIterStartChar :: MonadIO m => GlyphItemIter -> Int32 -> m ()
    setGlyphItemIterStartChar s val = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 24) (val :: Int32)

    #if ENABLE_OVERLOADING
    data GlyphItemIterStartCharFieldInfo
    instance AttrInfo GlyphItemIterStartCharFieldInfo where
        type AttrAllowedOps GlyphItemIterStartCharFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint GlyphItemIterStartCharFieldInfo = (~) Int32
        type AttrBaseTypeConstraint GlyphItemIterStartCharFieldInfo = (~) GlyphItemIter
        type AttrGetType GlyphItemIterStartCharFieldInfo = Int32
        type AttrLabel GlyphItemIterStartCharFieldInfo = "start_char"
        type AttrOrigin GlyphItemIterStartCharFieldInfo = GlyphItemIter
        attrGet _ = getGlyphItemIterStartChar
        attrSet _ = setGlyphItemIterStartChar
        attrConstruct = undefined
        attrClear _ = undefined

    glyphItemIter_startChar :: AttrLabelProxy "startChar"
    glyphItemIter_startChar = AttrLabelProxy

    #endif

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

    @
    'Data.GI.Base.Attributes.get' glyphItemIter #endGlyph
    @
    -}
    getGlyphItemIterEndGlyph :: MonadIO m => GlyphItemIter -> m Int32
    getGlyphItemIterEndGlyph s = liftIO $ withManagedPtr s $ \ptr -> do
        val <- peek (ptr `plusPtr` 28) :: IO Int32
        return val

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

    @
    'Data.GI.Base.Attributes.set' glyphItemIter [ #endGlyph 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setGlyphItemIterEndGlyph :: MonadIO m => GlyphItemIter -> Int32 -> m ()
    setGlyphItemIterEndGlyph s val = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 28) (val :: Int32)

    #if ENABLE_OVERLOADING
    data GlyphItemIterEndGlyphFieldInfo
    instance AttrInfo GlyphItemIterEndGlyphFieldInfo where
        type AttrAllowedOps GlyphItemIterEndGlyphFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint GlyphItemIterEndGlyphFieldInfo = (~) Int32
        type AttrBaseTypeConstraint GlyphItemIterEndGlyphFieldInfo = (~) GlyphItemIter
        type AttrGetType GlyphItemIterEndGlyphFieldInfo = Int32
        type AttrLabel GlyphItemIterEndGlyphFieldInfo = "end_glyph"
        type AttrOrigin GlyphItemIterEndGlyphFieldInfo = GlyphItemIter
        attrGet _ = getGlyphItemIterEndGlyph
        attrSet _ = setGlyphItemIterEndGlyph
        attrConstruct = undefined
        attrClear _ = undefined

    glyphItemIter_endGlyph :: AttrLabelProxy "endGlyph"
    glyphItemIter_endGlyph = AttrLabelProxy

    #endif

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

    @
    'Data.GI.Base.Attributes.get' glyphItemIter #endIndex
    @
    -}
    getGlyphItemIterEndIndex :: MonadIO m => GlyphItemIter -> m Int32
    getGlyphItemIterEndIndex s = liftIO $ withManagedPtr s $ \ptr -> do
        val <- peek (ptr `plusPtr` 32) :: IO Int32
        return val

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

    @
    'Data.GI.Base.Attributes.set' glyphItemIter [ #endIndex 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setGlyphItemIterEndIndex :: MonadIO m => GlyphItemIter -> Int32 -> m ()
    setGlyphItemIterEndIndex s val = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 32) (val :: Int32)

    #if ENABLE_OVERLOADING
    data GlyphItemIterEndIndexFieldInfo
    instance AttrInfo GlyphItemIterEndIndexFieldInfo where
        type AttrAllowedOps GlyphItemIterEndIndexFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint GlyphItemIterEndIndexFieldInfo = (~) Int32
        type AttrBaseTypeConstraint GlyphItemIterEndIndexFieldInfo = (~) GlyphItemIter
        type AttrGetType GlyphItemIterEndIndexFieldInfo = Int32
        type AttrLabel GlyphItemIterEndIndexFieldInfo = "end_index"
        type AttrOrigin GlyphItemIterEndIndexFieldInfo = GlyphItemIter
        attrGet _ = getGlyphItemIterEndIndex
        attrSet _ = setGlyphItemIterEndIndex
        attrConstruct = undefined
        attrClear _ = undefined

    glyphItemIter_endIndex :: AttrLabelProxy "endIndex"
    glyphItemIter_endIndex = AttrLabelProxy

    #endif

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

    @
    'Data.GI.Base.Attributes.get' glyphItemIter #endChar
    @
    -}
    getGlyphItemIterEndChar :: MonadIO m => GlyphItemIter -> m Int32
    getGlyphItemIterEndChar s = liftIO $ withManagedPtr s $ \ptr -> do
        val <- peek (ptr `plusPtr` 36) :: IO Int32
        return val

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

    @
    'Data.GI.Base.Attributes.set' glyphItemIter [ #endChar 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setGlyphItemIterEndChar :: MonadIO m => GlyphItemIter -> Int32 -> m ()
    setGlyphItemIterEndChar s val = liftIO $ withManagedPtr s $ \ptr -> do
        poke (ptr `plusPtr` 36) (val :: Int32)

    #if ENABLE_OVERLOADING
    data GlyphItemIterEndCharFieldInfo
    instance AttrInfo GlyphItemIterEndCharFieldInfo where
        type AttrAllowedOps GlyphItemIterEndCharFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint GlyphItemIterEndCharFieldInfo = (~) Int32
        type AttrBaseTypeConstraint GlyphItemIterEndCharFieldInfo = (~) GlyphItemIter
        type AttrGetType GlyphItemIterEndCharFieldInfo = Int32
        type AttrLabel GlyphItemIterEndCharFieldInfo = "end_char"
        type AttrOrigin GlyphItemIterEndCharFieldInfo = GlyphItemIter
        attrGet _ = getGlyphItemIterEndChar
        attrSet _ = setGlyphItemIterEndChar
        attrConstruct = undefined
        attrClear _ = undefined

    glyphItemIter_endChar :: AttrLabelProxy "endChar"
    glyphItemIter_endChar = AttrLabelProxy

    #endif

    #if ENABLE_OVERLOADING
    instance O.HasAttributeList GlyphItemIter
    type instance O.AttributeList GlyphItemIter = GlyphItemIterAttributeList
    type GlyphItemIterAttributeList = ('[ '("glyphItem", GlyphItemIterGlyphItemFieldInfo), '("text", GlyphItemIterTextFieldInfo), '("startGlyph", GlyphItemIterStartGlyphFieldInfo), '("startIndex", GlyphItemIterStartIndexFieldInfo), '("startChar", GlyphItemIterStartCharFieldInfo), '("endGlyph", GlyphItemIterEndGlyphFieldInfo), '("endIndex", GlyphItemIterEndIndexFieldInfo), '("endChar", GlyphItemIterEndCharFieldInfo)] :: [(Symbol, *)])
    #endif

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

    foreign import ccall "pango_glyph_item_iter_copy" pango_glyph_item_iter_copy ::
        Ptr GlyphItemIter ->                    -- orig : TInterface (Name {namespace = "Pango", name = "GlyphItemIter"})
        IO (Ptr GlyphItemIter)

    {- |
    Make a shallow copy of an existing 'GI.Pango.Structs.GlyphItemIter.GlyphItemIter' structure.

    /Since: 1.22/
    -}
    glyphItemIterCopy ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        GlyphItemIter
        {- ^ /@orig@/: a 'GI.Pango.Structs.GlyphItemIter.GlyphItemIter', may be 'Nothing' -}
        -> m (Maybe GlyphItemIter)
        {- ^ __Returns:__ the newly allocated 'GI.Pango.Structs.GlyphItemIter.GlyphItemIter', which should
                  be freed with 'GI.Pango.Structs.GlyphItemIter.glyphItemIterFree', or 'Nothing'
                  if /@orig@/ was 'Nothing'. -}
    glyphItemIterCopy orig = liftIO $ do
        orig' <- unsafeManagedPtrGetPtr orig
        result <- pango_glyph_item_iter_copy orig'
        maybeResult <- convertIfNonNull result $ \result' -> do
            result'' <- (wrapBoxed GlyphItemIter) result'
            return result''
        touchManagedPtr orig
        return maybeResult

    #if ENABLE_OVERLOADING
    data GlyphItemIterCopyMethodInfo
    instance (signature ~ (m (Maybe GlyphItemIter)), MonadIO m) => O.MethodInfo GlyphItemIterCopyMethodInfo GlyphItemIter signature where
        overloadedMethod _ = glyphItemIterCopy

    #endif

    -- method GlyphItemIter::free
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "iter", argType = TInterface (Name {namespace = "Pango", name = "GlyphItemIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoGlyphItemIter, 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_glyph_item_iter_free" pango_glyph_item_iter_free ::
        Ptr GlyphItemIter ->                    -- iter : TInterface (Name {namespace = "Pango", name = "GlyphItemIter"})
        IO ()

    {- |
    Frees a 'GI.Pango.Structs.GlyphItemIter.GlyphItemIter' created by 'GI.Pango.Structs.GlyphItemIter.glyphItemIterCopy'.

    /Since: 1.22/
    -}
    glyphItemIterFree ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        GlyphItemIter
        {- ^ /@iter@/: a 'GI.Pango.Structs.GlyphItemIter.GlyphItemIter', may be 'Nothing' -}
        -> m ()
    glyphItemIterFree iter = liftIO $ do
        iter' <- unsafeManagedPtrGetPtr iter
        pango_glyph_item_iter_free iter'
        touchManagedPtr iter
        return ()

    #if ENABLE_OVERLOADING
    data GlyphItemIterFreeMethodInfo
    instance (signature ~ (m ()), MonadIO m) => O.MethodInfo GlyphItemIterFreeMethodInfo GlyphItemIter signature where
        overloadedMethod _ = glyphItemIterFree

    #endif

    -- method GlyphItemIter::init_end
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "iter", argType = TInterface (Name {namespace = "Pango", name = "GlyphItemIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoGlyphItemIter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "glyph_item", argType = TInterface (Name {namespace = "Pango", name = "GlyphItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the glyph item to iterate over", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "text corresponding to the glyph item", 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_glyph_item_iter_init_end" pango_glyph_item_iter_init_end ::
        Ptr GlyphItemIter ->                    -- iter : TInterface (Name {namespace = "Pango", name = "GlyphItemIter"})
        Ptr Pango.GlyphItem.GlyphItem ->        -- glyph_item : TInterface (Name {namespace = "Pango", name = "GlyphItem"})
        CString ->                              -- text : TBasicType TUTF8
        IO CInt

    {- |
    Initializes a 'GI.Pango.Structs.GlyphItemIter.GlyphItemIter' structure to point to the
    last cluster in a glyph item.
    See 'GI.Pango.Structs.GlyphItemIter.GlyphItemIter' for details of cluster orders.

    /Since: 1.22/
    -}
    glyphItemIterInitEnd ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        GlyphItemIter
        {- ^ /@iter@/: a 'GI.Pango.Structs.GlyphItemIter.GlyphItemIter' -}
        -> Pango.GlyphItem.GlyphItem
        {- ^ /@glyphItem@/: the glyph item to iterate over -}
        -> T.Text
        {- ^ /@text@/: text corresponding to the glyph item -}
        -> m Bool
        {- ^ __Returns:__ 'False' if there are no clusters in the glyph item -}
    glyphItemIterInitEnd iter glyphItem text = liftIO $ do
        iter' <- unsafeManagedPtrGetPtr iter
        glyphItem' <- unsafeManagedPtrGetPtr glyphItem
        text' <- textToCString text
        result <- pango_glyph_item_iter_init_end iter' glyphItem' text'
        let result' = (/= 0) result
        touchManagedPtr iter
        touchManagedPtr glyphItem
        freeMem text'
        return result'

    #if ENABLE_OVERLOADING
    data GlyphItemIterInitEndMethodInfo
    instance (signature ~ (Pango.GlyphItem.GlyphItem -> T.Text -> m Bool), MonadIO m) => O.MethodInfo GlyphItemIterInitEndMethodInfo GlyphItemIter signature where
        overloadedMethod _ = glyphItemIterInitEnd

    #endif

    -- method GlyphItemIter::init_start
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "iter", argType = TInterface (Name {namespace = "Pango", name = "GlyphItemIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoGlyphItemIter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "glyph_item", argType = TInterface (Name {namespace = "Pango", name = "GlyphItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the glyph item to iterate over", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "text corresponding to the glyph item", 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_glyph_item_iter_init_start" pango_glyph_item_iter_init_start ::
        Ptr GlyphItemIter ->                    -- iter : TInterface (Name {namespace = "Pango", name = "GlyphItemIter"})
        Ptr Pango.GlyphItem.GlyphItem ->        -- glyph_item : TInterface (Name {namespace = "Pango", name = "GlyphItem"})
        CString ->                              -- text : TBasicType TUTF8
        IO CInt

    {- |
    Initializes a 'GI.Pango.Structs.GlyphItemIter.GlyphItemIter' structure to point to the
    first cluster in a glyph item.
    See 'GI.Pango.Structs.GlyphItemIter.GlyphItemIter' for details of cluster orders.

    /Since: 1.22/
    -}
    glyphItemIterInitStart ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        GlyphItemIter
        {- ^ /@iter@/: a 'GI.Pango.Structs.GlyphItemIter.GlyphItemIter' -}
        -> Pango.GlyphItem.GlyphItem
        {- ^ /@glyphItem@/: the glyph item to iterate over -}
        -> T.Text
        {- ^ /@text@/: text corresponding to the glyph item -}
        -> m Bool
        {- ^ __Returns:__ 'False' if there are no clusters in the glyph item -}
    glyphItemIterInitStart iter glyphItem text = liftIO $ do
        iter' <- unsafeManagedPtrGetPtr iter
        glyphItem' <- unsafeManagedPtrGetPtr glyphItem
        text' <- textToCString text
        result <- pango_glyph_item_iter_init_start iter' glyphItem' text'
        let result' = (/= 0) result
        touchManagedPtr iter
        touchManagedPtr glyphItem
        freeMem text'
        return result'

    #if ENABLE_OVERLOADING
    data GlyphItemIterInitStartMethodInfo
    instance (signature ~ (Pango.GlyphItem.GlyphItem -> T.Text -> m Bool), MonadIO m) => O.MethodInfo GlyphItemIterInitStartMethodInfo GlyphItemIter signature where
        overloadedMethod _ = glyphItemIterInitStart

    #endif

    -- method GlyphItemIter::next_cluster
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "iter", argType = TInterface (Name {namespace = "Pango", name = "GlyphItemIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoGlyphItemIter", 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_glyph_item_iter_next_cluster" pango_glyph_item_iter_next_cluster ::
        Ptr GlyphItemIter ->                    -- iter : TInterface (Name {namespace = "Pango", name = "GlyphItemIter"})
        IO CInt

    {- |
    Advances the iterator to the next cluster in the glyph item.
    See 'GI.Pango.Structs.GlyphItemIter.GlyphItemIter' for details of cluster orders.

    /Since: 1.22/
    -}
    glyphItemIterNextCluster ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        GlyphItemIter
        {- ^ /@iter@/: a 'GI.Pango.Structs.GlyphItemIter.GlyphItemIter' -}
        -> m Bool
        {- ^ __Returns:__ 'True' if the iterator was advanced, 'False' if we were already on the
     last cluster. -}
    glyphItemIterNextCluster iter = liftIO $ do
        iter' <- unsafeManagedPtrGetPtr iter
        result <- pango_glyph_item_iter_next_cluster iter'
        let result' = (/= 0) result
        touchManagedPtr iter
        return result'

    #if ENABLE_OVERLOADING
    data GlyphItemIterNextClusterMethodInfo
    instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo GlyphItemIterNextClusterMethodInfo GlyphItemIter signature where
        overloadedMethod _ = glyphItemIterNextCluster

    #endif

    -- method GlyphItemIter::prev_cluster
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "iter", argType = TInterface (Name {namespace = "Pango", name = "GlyphItemIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoGlyphItemIter", 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_glyph_item_iter_prev_cluster" pango_glyph_item_iter_prev_cluster ::
        Ptr GlyphItemIter ->                    -- iter : TInterface (Name {namespace = "Pango", name = "GlyphItemIter"})
        IO CInt

    {- |
    Moves the iterator to the preceding cluster in the glyph item.
    See 'GI.Pango.Structs.GlyphItemIter.GlyphItemIter' for details of cluster orders.

    /Since: 1.22/
    -}
    glyphItemIterPrevCluster ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        GlyphItemIter
        {- ^ /@iter@/: a 'GI.Pango.Structs.GlyphItemIter.GlyphItemIter' -}
        -> m Bool
        {- ^ __Returns:__ 'True' if the iterator was moved, 'False' if we were already on the
     first cluster. -}
    glyphItemIterPrevCluster iter = liftIO $ do
        iter' <- unsafeManagedPtrGetPtr iter
        result <- pango_glyph_item_iter_prev_cluster iter'
        let result' = (/= 0) result
        touchManagedPtr iter
        return result'

    #if ENABLE_OVERLOADING
    data GlyphItemIterPrevClusterMethodInfo
    instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo GlyphItemIterPrevClusterMethodInfo GlyphItemIter signature where
        overloadedMethod _ = glyphItemIterPrevCluster

    #endif

    #if ENABLE_OVERLOADING
    type family ResolveGlyphItemIterMethod (t :: Symbol) (o :: *) :: * where
        ResolveGlyphItemIterMethod "copy" o = GlyphItemIterCopyMethodInfo
        ResolveGlyphItemIterMethod "free" o = GlyphItemIterFreeMethodInfo
        ResolveGlyphItemIterMethod "initEnd" o = GlyphItemIterInitEndMethodInfo
        ResolveGlyphItemIterMethod "initStart" o = GlyphItemIterInitStartMethodInfo
        ResolveGlyphItemIterMethod "nextCluster" o = GlyphItemIterNextClusterMethodInfo
        ResolveGlyphItemIterMethod "prevCluster" o = GlyphItemIterPrevClusterMethodInfo
        ResolveGlyphItemIterMethod l o = O.MethodResolutionFailed l o

    instance (info ~ ResolveGlyphItemIterMethod t GlyphItemIter, O.MethodInfo info GlyphItemIter p) => O.IsLabelProxy t (GlyphItemIter -> p) where
        fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

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