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

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 (MIN_VERSION_haskell_gi_overloading(1,0,0) \
       && !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.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL

import {-# SOURCE #-} qualified GI.Pango.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) => OL.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