{- |
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.GlyphItem.GlyphItem' is a pair of a 'GI.Pango.Structs.Item.Item' and the glyphs
resulting from shaping the text corresponding to an item.
As an example of the usage of 'GI.Pango.Structs.GlyphItem.GlyphItem', the results
of shaping text with 'GI.Pango.Objects.Layout.Layout' is a list of 'GI.Pango.Structs.LayoutLine.LayoutLine',
each of which contains a list of 'GI.Pango.Structs.GlyphItem.GlyphItem'.
-}

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

module GI.Pango.Structs.GlyphItem
    (

-- * Exported types
    GlyphItem(..)                           ,
    newZeroGlyphItem                        ,
    noGlyphItem                             ,


 -- * Methods
-- ** applyAttrs #method:applyAttrs#

#if ENABLE_OVERLOADING
    GlyphItemApplyAttrsMethodInfo           ,
#endif
    glyphItemApplyAttrs                     ,


-- ** copy #method:copy#

#if ENABLE_OVERLOADING
    GlyphItemCopyMethodInfo                 ,
#endif
    glyphItemCopy                           ,


-- ** free #method:free#

#if ENABLE_OVERLOADING
    GlyphItemFreeMethodInfo                 ,
#endif
    glyphItemFree                           ,


-- ** getLogicalWidths #method:getLogicalWidths#

#if ENABLE_OVERLOADING
    GlyphItemGetLogicalWidthsMethodInfo     ,
#endif
    glyphItemGetLogicalWidths               ,


-- ** letterSpace #method:letterSpace#

#if ENABLE_OVERLOADING
    GlyphItemLetterSpaceMethodInfo          ,
#endif
    glyphItemLetterSpace                    ,


-- ** split #method:split#

#if ENABLE_OVERLOADING
    GlyphItemSplitMethodInfo                ,
#endif
    glyphItemSplit                          ,




 -- * Properties
-- ** glyphs #attr:glyphs#
{- | corresponding 'GI.Pango.Structs.GlyphString.GlyphString'.
-}
    clearGlyphItemGlyphs                    ,
    getGlyphItemGlyphs                      ,
#if ENABLE_OVERLOADING
    glyphItem_glyphs                        ,
#endif
    setGlyphItemGlyphs                      ,


-- ** item #attr:item#
{- | corresponding 'GI.Pango.Structs.Item.Item'.
-}
    clearGlyphItemItem                      ,
    getGlyphItemItem                        ,
#if ENABLE_OVERLOADING
    glyphItem_item                          ,
#endif
    setGlyphItemItem                        ,




    ) 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.AttrList as Pango.AttrList
import {-# SOURCE #-} qualified GI.Pango.Structs.GlyphString as Pango.GlyphString
import {-# SOURCE #-} qualified GI.Pango.Structs.Item as Pango.Item
import {-# SOURCE #-} qualified GI.Pango.Structs.LogAttr as Pango.LogAttr

-- | Memory-managed wrapper type.
newtype GlyphItem = GlyphItem (ManagedPtr GlyphItem)
foreign import ccall "pango_glyph_item_get_type" c_pango_glyph_item_get_type ::
    IO GType

instance BoxedObject GlyphItem where
    boxedType _ = c_pango_glyph_item_get_type

-- | Construct a `GlyphItem` struct initialized to zero.
newZeroGlyphItem :: MonadIO m => m GlyphItem
newZeroGlyphItem = liftIO $ callocBoxedBytes 16 >>= wrapBoxed GlyphItem

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


-- | A convenience alias for `Nothing` :: `Maybe` `GlyphItem`.
noGlyphItem :: Maybe GlyphItem
noGlyphItem = Nothing

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

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

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

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

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

#if ENABLE_OVERLOADING
data GlyphItemItemFieldInfo
instance AttrInfo GlyphItemItemFieldInfo where
    type AttrAllowedOps GlyphItemItemFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint GlyphItemItemFieldInfo = (~) (Ptr Pango.Item.Item)
    type AttrBaseTypeConstraint GlyphItemItemFieldInfo = (~) GlyphItem
    type AttrGetType GlyphItemItemFieldInfo = Maybe Pango.Item.Item
    type AttrLabel GlyphItemItemFieldInfo = "item"
    type AttrOrigin GlyphItemItemFieldInfo = GlyphItem
    attrGet _ = getGlyphItemItem
    attrSet _ = setGlyphItemItem
    attrConstruct = undefined
    attrClear _ = clearGlyphItemItem

glyphItem_item :: AttrLabelProxy "item"
glyphItem_item = AttrLabelProxy

#endif


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

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

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

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

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

#if ENABLE_OVERLOADING
data GlyphItemGlyphsFieldInfo
instance AttrInfo GlyphItemGlyphsFieldInfo where
    type AttrAllowedOps GlyphItemGlyphsFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint GlyphItemGlyphsFieldInfo = (~) (Ptr Pango.GlyphString.GlyphString)
    type AttrBaseTypeConstraint GlyphItemGlyphsFieldInfo = (~) GlyphItem
    type AttrGetType GlyphItemGlyphsFieldInfo = Maybe Pango.GlyphString.GlyphString
    type AttrLabel GlyphItemGlyphsFieldInfo = "glyphs"
    type AttrOrigin GlyphItemGlyphsFieldInfo = GlyphItem
    attrGet _ = getGlyphItemGlyphs
    attrSet _ = setGlyphItemGlyphs
    attrConstruct = undefined
    attrClear _ = clearGlyphItemGlyphs

glyphItem_glyphs :: AttrLabelProxy "glyphs"
glyphItem_glyphs = AttrLabelProxy

#endif



#if ENABLE_OVERLOADING
instance O.HasAttributeList GlyphItem
type instance O.AttributeList GlyphItem = GlyphItemAttributeList
type GlyphItemAttributeList = ('[ '("item", GlyphItemItemFieldInfo), '("glyphs", GlyphItemGlyphsFieldInfo)] :: [(Symbol, *)])
#endif

-- method GlyphItem::apply_attrs
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "glyph_item", argType = TInterface (Name {namespace = "Pango", name = "GlyphItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a shaped item", 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 that @list applies to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "list", argType = TInterface (Name {namespace = "Pango", name = "AttrList"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoAttrList", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TGSList (TInterface (Name {namespace = "Pango", name = "GlyphItem"})))
-- throws : False
-- Skip return : False

foreign import ccall "pango_glyph_item_apply_attrs" pango_glyph_item_apply_attrs ::
    Ptr GlyphItem ->                        -- glyph_item : TInterface (Name {namespace = "Pango", name = "GlyphItem"})
    CString ->                              -- text : TBasicType TUTF8
    Ptr Pango.AttrList.AttrList ->          -- list : TInterface (Name {namespace = "Pango", name = "AttrList"})
    IO (Ptr (GSList (Ptr GlyphItem)))

{- |
Splits a shaped item (PangoGlyphItem) into multiple items based
on an attribute list. The idea is that if you have attributes
that don\'t affect shaping, such as color or underline, to avoid
affecting shaping, you filter them out ('GI.Pango.Structs.AttrList.attrListFilter'),
apply the shaping process and then reapply them to the result using
this function.

All attributes that start or end inside a cluster are applied
to that cluster; for instance, if half of a cluster is underlined
and the other-half strikethrough, then the cluster will end
up with both underline and strikethrough attributes. In these
cases, it may happen that item->extra_attrs for some of the
result items can have multiple attributes of the same type.

This function takes ownership of /@glyphItem@/; it will be reused
as one of the elements in the list.

/Since: 1.2/
-}
glyphItemApplyAttrs ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    GlyphItem
    {- ^ /@glyphItem@/: a shaped item -}
    -> T.Text
    {- ^ /@text@/: text that /@list@/ applies to -}
    -> Pango.AttrList.AttrList
    {- ^ /@list@/: a 'GI.Pango.Structs.AttrList.AttrList' -}
    -> m [GlyphItem]
    {- ^ __Returns:__ a
  list of glyph items resulting from splitting /@glyphItem@/. Free
  the elements using 'GI.Pango.Structs.GlyphItem.glyphItemFree', the list using
  @/g_slist_free()/@. -}
glyphItemApplyAttrs glyphItem text list = liftIO $ do
    glyphItem' <- unsafeManagedPtrGetPtr glyphItem
    text' <- textToCString text
    list' <- unsafeManagedPtrGetPtr list
    result <- pango_glyph_item_apply_attrs glyphItem' text' list'
    result' <- unpackGSList result
    result'' <- mapM (wrapBoxed GlyphItem) result'
    g_slist_free result
    touchManagedPtr glyphItem
    touchManagedPtr list
    freeMem text'
    return result''

#if ENABLE_OVERLOADING
data GlyphItemApplyAttrsMethodInfo
instance (signature ~ (T.Text -> Pango.AttrList.AttrList -> m [GlyphItem]), MonadIO m) => O.MethodInfo GlyphItemApplyAttrsMethodInfo GlyphItem signature where
    overloadedMethod _ = glyphItemApplyAttrs

#endif

-- method GlyphItem::copy
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "orig", argType = TInterface (Name {namespace = "Pango", name = "GlyphItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoGlyphItem, may be %NULL", 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_glyph_item_copy" pango_glyph_item_copy ::
    Ptr GlyphItem ->                        -- orig : TInterface (Name {namespace = "Pango", name = "GlyphItem"})
    IO (Ptr GlyphItem)

{- |
Make a deep copy of an existing 'GI.Pango.Structs.GlyphItem.GlyphItem' structure.

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

#if ENABLE_OVERLOADING
data GlyphItemCopyMethodInfo
instance (signature ~ (m (Maybe GlyphItem)), MonadIO m) => O.MethodInfo GlyphItemCopyMethodInfo GlyphItem signature where
    overloadedMethod _ = glyphItemCopy

#endif

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

{- |
Frees a 'GI.Pango.Structs.GlyphItem.GlyphItem' and resources to which it points.

/Since: 1.6/
-}
glyphItemFree ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    GlyphItem
    {- ^ /@glyphItem@/: a 'GI.Pango.Structs.GlyphItem.GlyphItem', may be 'Nothing' -}
    -> m ()
glyphItemFree glyphItem = liftIO $ do
    glyphItem' <- unsafeManagedPtrGetPtr glyphItem
    pango_glyph_item_free glyphItem'
    touchManagedPtr glyphItem
    return ()

#if ENABLE_OVERLOADING
data GlyphItemFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo GlyphItemFreeMethodInfo GlyphItem signature where
    overloadedMethod _ = glyphItemFree

#endif

-- method GlyphItem::get_logical_widths
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "glyph_item", argType = TInterface (Name {namespace = "Pango", name = "GlyphItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoGlyphItem", 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 that @glyph_item corresponds to\n  (glyph_item->item->offset is an offset from the\n   start of @text)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "logical_widths", argType = TCArray False (-1) (-1) (TBasicType TInt), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an array whose length is the number of\n                 characters in glyph_item (equal to\n                 glyph_item->item->num_chars) to be filled in with\n                 the resulting character widths.", 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_get_logical_widths" pango_glyph_item_get_logical_widths ::
    Ptr GlyphItem ->                        -- glyph_item : TInterface (Name {namespace = "Pango", name = "GlyphItem"})
    CString ->                              -- text : TBasicType TUTF8
    Ptr Int32 ->                            -- logical_widths : TCArray False (-1) (-1) (TBasicType TInt)
    IO ()

{- |
Given a 'GI.Pango.Structs.GlyphItem.GlyphItem' and the corresponding
text, determine the screen width corresponding to each character. When
multiple characters compose a single cluster, the width of the entire
cluster is divided equally among the characters.

See also 'GI.Pango.Structs.GlyphString.glyphStringGetLogicalWidths'.

/Since: 1.26/
-}
glyphItemGetLogicalWidths ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    GlyphItem
    {- ^ /@glyphItem@/: a 'GI.Pango.Structs.GlyphItem.GlyphItem' -}
    -> T.Text
    {- ^ /@text@/: text that /@glyphItem@/ corresponds to
  (glyph_item->item->offset is an offset from the
   start of /@text@/) -}
    -> [Int32]
    {- ^ /@logicalWidths@/: an array whose length is the number of
                 characters in glyph_item (equal to
                 glyph_item->item->num_chars) to be filled in with
                 the resulting character widths. -}
    -> m ()
glyphItemGetLogicalWidths glyphItem text logicalWidths = liftIO $ do
    glyphItem' <- unsafeManagedPtrGetPtr glyphItem
    text' <- textToCString text
    logicalWidths' <- packStorableArray logicalWidths
    pango_glyph_item_get_logical_widths glyphItem' text' logicalWidths'
    touchManagedPtr glyphItem
    freeMem text'
    freeMem logicalWidths'
    return ()

#if ENABLE_OVERLOADING
data GlyphItemGetLogicalWidthsMethodInfo
instance (signature ~ (T.Text -> [Int32] -> m ()), MonadIO m) => O.MethodInfo GlyphItemGetLogicalWidthsMethodInfo GlyphItem signature where
    overloadedMethod _ = glyphItemGetLogicalWidths

#endif

-- method GlyphItem::letter_space
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "glyph_item", argType = TInterface (Name {namespace = "Pango", name = "GlyphItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoGlyphItem", 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 that @glyph_item corresponds to\n  (glyph_item->item->offset is an offset from the\n   start of @text)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "log_attrs", argType = TCArray False (-1) (-1) (TInterface (Name {namespace = "Pango", name = "LogAttr"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "logical attributes for the item\n  (the first logical attribute refers to the position\n  before the first character in the item)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "letter_spacing", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "amount of letter spacing to add\n  in Pango units. May be negative, though too large\n  negative values will give ugly results.", 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_letter_space" pango_glyph_item_letter_space ::
    Ptr GlyphItem ->                        -- glyph_item : TInterface (Name {namespace = "Pango", name = "GlyphItem"})
    CString ->                              -- text : TBasicType TUTF8
    Ptr Pango.LogAttr.LogAttr ->            -- log_attrs : TCArray False (-1) (-1) (TInterface (Name {namespace = "Pango", name = "LogAttr"}))
    Int32 ->                                -- letter_spacing : TBasicType TInt
    IO ()

{- |
Adds spacing between the graphemes of /@glyphItem@/ to
give the effect of typographic letter spacing.

/Since: 1.6/
-}
glyphItemLetterSpace ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    GlyphItem
    {- ^ /@glyphItem@/: a 'GI.Pango.Structs.GlyphItem.GlyphItem' -}
    -> T.Text
    {- ^ /@text@/: text that /@glyphItem@/ corresponds to
  (glyph_item->item->offset is an offset from the
   start of /@text@/) -}
    -> [Pango.LogAttr.LogAttr]
    {- ^ /@logAttrs@/: logical attributes for the item
  (the first logical attribute refers to the position
  before the first character in the item) -}
    -> Int32
    {- ^ /@letterSpacing@/: amount of letter spacing to add
  in Pango units. May be negative, though too large
  negative values will give ugly results. -}
    -> m ()
glyphItemLetterSpace glyphItem text logAttrs letterSpacing = liftIO $ do
    glyphItem' <- unsafeManagedPtrGetPtr glyphItem
    text' <- textToCString text
    logAttrs' <- mapM unsafeManagedPtrGetPtr logAttrs
    logAttrs'' <- packBlockArray 52 logAttrs'
    pango_glyph_item_letter_space glyphItem' text' logAttrs'' letterSpacing
    touchManagedPtr glyphItem
    mapM_ touchManagedPtr logAttrs
    freeMem text'
    freeMem logAttrs''
    return ()

#if ENABLE_OVERLOADING
data GlyphItemLetterSpaceMethodInfo
instance (signature ~ (T.Text -> [Pango.LogAttr.LogAttr] -> Int32 -> m ()), MonadIO m) => O.MethodInfo GlyphItemLetterSpaceMethodInfo GlyphItem signature where
    overloadedMethod _ = glyphItemLetterSpace

#endif

-- method GlyphItem::split
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "orig", argType = TInterface (Name {namespace = "Pango", name = "GlyphItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoItem", 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 to which positions in @orig apply", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "split_index", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "byte index of position to split item, relative to the start of the item", 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_glyph_item_split" pango_glyph_item_split ::
    Ptr GlyphItem ->                        -- orig : TInterface (Name {namespace = "Pango", name = "GlyphItem"})
    CString ->                              -- text : TBasicType TUTF8
    Int32 ->                                -- split_index : TBasicType TInt
    IO (Ptr GlyphItem)

{- |
Modifies /@orig@/ to cover only the text after /@splitIndex@/, and
returns a new item that covers the text before /@splitIndex@/ that
used to be in /@orig@/. You can think of /@splitIndex@/ as the length of
the returned item. /@splitIndex@/ may not be 0, and it may not be
greater than or equal to the length of /@orig@/ (that is, there must
be at least one byte assigned to each item, you can\'t create a
zero-length item).

This function is similar in function to 'GI.Pango.Structs.Item.itemSplit' (and uses
it internally.)

/Since: 1.2/
-}
glyphItemSplit ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    GlyphItem
    {- ^ /@orig@/: a 'GI.Pango.Structs.Item.Item' -}
    -> T.Text
    {- ^ /@text@/: text to which positions in /@orig@/ apply -}
    -> Int32
    {- ^ /@splitIndex@/: byte index of position to split item, relative to the start of the item -}
    -> m GlyphItem
    {- ^ __Returns:__ the newly allocated item representing text before
              /@splitIndex@/, which should be freed
              with 'GI.Pango.Structs.GlyphItem.glyphItemFree'. -}
glyphItemSplit orig text splitIndex = liftIO $ do
    orig' <- unsafeManagedPtrGetPtr orig
    text' <- textToCString text
    result <- pango_glyph_item_split orig' text' splitIndex
    checkUnexpectedReturnNULL "glyphItemSplit" result
    result' <- (wrapBoxed GlyphItem) result
    touchManagedPtr orig
    freeMem text'
    return result'

#if ENABLE_OVERLOADING
data GlyphItemSplitMethodInfo
instance (signature ~ (T.Text -> Int32 -> m GlyphItem), MonadIO m) => O.MethodInfo GlyphItemSplitMethodInfo GlyphItem signature where
    overloadedMethod _ = glyphItemSplit

#endif

#if ENABLE_OVERLOADING
type family ResolveGlyphItemMethod (t :: Symbol) (o :: *) :: * where
    ResolveGlyphItemMethod "applyAttrs" o = GlyphItemApplyAttrsMethodInfo
    ResolveGlyphItemMethod "copy" o = GlyphItemCopyMethodInfo
    ResolveGlyphItemMethod "free" o = GlyphItemFreeMethodInfo
    ResolveGlyphItemMethod "letterSpace" o = GlyphItemLetterSpaceMethodInfo
    ResolveGlyphItemMethod "split" o = GlyphItemSplitMethodInfo
    ResolveGlyphItemMethod "getLogicalWidths" o = GlyphItemGetLogicalWidthsMethodInfo
    ResolveGlyphItemMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveGlyphItemMethod t GlyphItem, O.MethodInfo info GlyphItem p) => OL.IsLabel t (GlyphItem -> 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