{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- The @PangoItem@ structure stores information about a segment of text.
-- 
-- You typically obtain @PangoItems@ by itemizing a piece of text
-- with [func/@itemize@/].

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

module GI.Pango.Structs.Item
    ( 

-- * Exported types
    Item(..)                                ,
    newZeroItem                             ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [applyAttrs]("GI.Pango.Structs.Item#g:method:applyAttrs"), [copy]("GI.Pango.Structs.Item#g:method:copy"), [free]("GI.Pango.Structs.Item#g:method:free"), [split]("GI.Pango.Structs.Item#g:method:split").
-- 
-- ==== Getters
-- /None/.
-- 
-- ==== Setters
-- /None/.

#if defined(ENABLE_OVERLOADING)
    ResolveItemMethod                       ,
#endif

-- ** applyAttrs #method:applyAttrs#

#if defined(ENABLE_OVERLOADING)
    ItemApplyAttrsMethodInfo                ,
#endif
    itemApplyAttrs                          ,


-- ** copy #method:copy#

#if defined(ENABLE_OVERLOADING)
    ItemCopyMethodInfo                      ,
#endif
    itemCopy                                ,


-- ** free #method:free#

#if defined(ENABLE_OVERLOADING)
    ItemFreeMethodInfo                      ,
#endif
    itemFree                                ,


-- ** new #method:new#

    itemNew                                 ,


-- ** split #method:split#

#if defined(ENABLE_OVERLOADING)
    ItemSplitMethodInfo                     ,
#endif
    itemSplit                               ,




 -- * Properties


-- ** analysis #attr:analysis#
-- | analysis results for the item.

    getItemAnalysis                         ,
#if defined(ENABLE_OVERLOADING)
    item_analysis                           ,
#endif


-- ** length #attr:length#
-- | length of this item in bytes.

    getItemLength                           ,
#if defined(ENABLE_OVERLOADING)
    item_length                             ,
#endif
    setItemLength                           ,


-- ** numChars #attr:numChars#
-- | number of Unicode characters in the item.

    getItemNumChars                         ,
#if defined(ENABLE_OVERLOADING)
    item_numChars                           ,
#endif
    setItemNumChars                         ,


-- ** offset #attr:offset#
-- | byte offset of the start of this item in text.

    getItemOffset                           ,
#if defined(ENABLE_OVERLOADING)
    item_offset                             ,
#endif
    setItemOffset                           ,




    ) where

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

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
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 qualified GHC.Records as R

import {-# SOURCE #-} qualified GI.Pango.Structs.Analysis as Pango.Analysis
import {-# SOURCE #-} qualified GI.Pango.Structs.AttrIterator as Pango.AttrIterator

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

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

foreign import ccall "pango_item_get_type" c_pango_item_get_type :: 
    IO GType

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

instance B.Types.TypedObject Item where
    glibType :: IO GType
glibType = IO GType
c_pango_item_get_type

instance B.Types.GBoxed Item

-- | Convert 'Item' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe Item) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_pango_item_get_type
    gvalueSet_ :: Ptr GValue -> Maybe Item -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Item
P.Nothing = Ptr GValue -> Ptr Item -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (Ptr Item
forall a. Ptr a
FP.nullPtr :: FP.Ptr Item)
    gvalueSet_ Ptr GValue
gv (P.Just Item
obj) = Item -> (Ptr Item -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Item
obj (Ptr GValue -> Ptr Item -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe Item)
gvalueGet_ Ptr GValue
gv = do
        Ptr Item
ptr <- Ptr GValue -> IO (Ptr Item)
forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr Item)
        if Ptr Item
ptr Ptr Item -> Ptr Item -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr Item
forall a. Ptr a
FP.nullPtr
        then Item -> Maybe Item
forall a. a -> Maybe a
P.Just (Item -> Maybe Item) -> IO Item -> IO (Maybe Item)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr Item -> Item) -> Ptr Item -> IO Item
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr Item -> Item
Item Ptr Item
ptr
        else Maybe Item -> IO (Maybe Item)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Item
forall a. Maybe a
P.Nothing
        
    

-- | Construct a `Item` struct initialized to zero.
newZeroItem :: MonadIO m => m Item
newZeroItem :: forall (m :: * -> *). MonadIO m => m Item
newZeroItem = IO Item -> m Item
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Item -> m Item) -> IO Item -> m Item
forall a b. (a -> b) -> a -> b
$ Int -> IO (Ptr Item)
forall a. GBoxed a => Int -> IO (Ptr a)
callocBoxedBytes Int
64 IO (Ptr Item) -> (Ptr Item -> IO Item) -> IO Item
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr Item -> Item) -> Ptr Item -> IO Item
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Item -> Item
Item

instance tag ~ 'AttrSet => Constructible Item tag where
    new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr Item -> Item) -> [AttrOp Item tag] -> m Item
new ManagedPtr Item -> Item
_ [AttrOp Item tag]
attrs = do
        Item
o <- m Item
forall (m :: * -> *). MonadIO m => m Item
newZeroItem
        Item -> [AttrOp Item 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set Item
o [AttrOp Item tag]
[AttrOp Item 'AttrSet]
attrs
        Item -> m Item
forall (m :: * -> *) a. Monad m => a -> m a
return Item
o


-- | Get the value of the “@offset@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' item #offset
-- @
getItemOffset :: MonadIO m => Item -> m Int32
getItemOffset :: forall (m :: * -> *). MonadIO m => Item -> m Int32
getItemOffset Item
s = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ Item -> (Ptr Item -> IO Int32) -> IO Int32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Item
s ((Ptr Item -> IO Int32) -> IO Int32)
-> (Ptr Item -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \Ptr Item
ptr -> do
    Int32
val <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek (Ptr Item
ptr Ptr Item -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) :: IO Int32
    Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
val

-- | Set the value of the “@offset@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' item [ #offset 'Data.GI.Base.Attributes.:=' value ]
-- @
setItemOffset :: MonadIO m => Item -> Int32 -> m ()
setItemOffset :: forall (m :: * -> *). MonadIO m => Item -> Int32 -> m ()
setItemOffset Item
s Int32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Item -> (Ptr Item -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Item
s ((Ptr Item -> IO ()) -> IO ()) -> (Ptr Item -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Item
ptr -> do
    Ptr Int32 -> Int32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Item
ptr Ptr Item -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (Int32
val :: Int32)

#if defined(ENABLE_OVERLOADING)
data ItemOffsetFieldInfo
instance AttrInfo ItemOffsetFieldInfo where
    type AttrBaseTypeConstraint ItemOffsetFieldInfo = (~) Item
    type AttrAllowedOps ItemOffsetFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ItemOffsetFieldInfo = (~) Int32
    type AttrTransferTypeConstraint ItemOffsetFieldInfo = (~)Int32
    type AttrTransferType ItemOffsetFieldInfo = Int32
    type AttrGetType ItemOffsetFieldInfo = Int32
    type AttrLabel ItemOffsetFieldInfo = "offset"
    type AttrOrigin ItemOffsetFieldInfo = Item
    attrGet = getItemOffset
    attrSet = setItemOffset
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Pango.Structs.Item.offset"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.25/docs/GI-Pango-Structs-Item.html#g:attr:offset"
        })

item_offset :: AttrLabelProxy "offset"
item_offset = AttrLabelProxy

#endif


-- | Get the value of the “@length@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' item #length
-- @
getItemLength :: MonadIO m => Item -> m Int32
getItemLength :: forall (m :: * -> *). MonadIO m => Item -> m Int32
getItemLength Item
s = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ Item -> (Ptr Item -> IO Int32) -> IO Int32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Item
s ((Ptr Item -> IO Int32) -> IO Int32)
-> (Ptr Item -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \Ptr Item
ptr -> do
    Int32
val <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek (Ptr Item
ptr Ptr Item -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) :: IO Int32
    Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
val

-- | Set the value of the “@length@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' item [ #length 'Data.GI.Base.Attributes.:=' value ]
-- @
setItemLength :: MonadIO m => Item -> Int32 -> m ()
setItemLength :: forall (m :: * -> *). MonadIO m => Item -> Int32 -> m ()
setItemLength Item
s Int32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Item -> (Ptr Item -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Item
s ((Ptr Item -> IO ()) -> IO ()) -> (Ptr Item -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Item
ptr -> do
    Ptr Int32 -> Int32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Item
ptr Ptr Item -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) (Int32
val :: Int32)

#if defined(ENABLE_OVERLOADING)
data ItemLengthFieldInfo
instance AttrInfo ItemLengthFieldInfo where
    type AttrBaseTypeConstraint ItemLengthFieldInfo = (~) Item
    type AttrAllowedOps ItemLengthFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ItemLengthFieldInfo = (~) Int32
    type AttrTransferTypeConstraint ItemLengthFieldInfo = (~)Int32
    type AttrTransferType ItemLengthFieldInfo = Int32
    type AttrGetType ItemLengthFieldInfo = Int32
    type AttrLabel ItemLengthFieldInfo = "length"
    type AttrOrigin ItemLengthFieldInfo = Item
    attrGet = getItemLength
    attrSet = setItemLength
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Pango.Structs.Item.length"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.25/docs/GI-Pango-Structs-Item.html#g:attr:length"
        })

item_length :: AttrLabelProxy "length"
item_length = AttrLabelProxy

#endif


-- | Get the value of the “@num_chars@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' item #numChars
-- @
getItemNumChars :: MonadIO m => Item -> m Int32
getItemNumChars :: forall (m :: * -> *). MonadIO m => Item -> m Int32
getItemNumChars Item
s = IO Int32 -> m Int32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ Item -> (Ptr Item -> IO Int32) -> IO Int32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Item
s ((Ptr Item -> IO Int32) -> IO Int32)
-> (Ptr Item -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \Ptr Item
ptr -> do
    Int32
val <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek (Ptr Item
ptr Ptr Item -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) :: IO Int32
    Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
val

-- | Set the value of the “@num_chars@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' item [ #numChars 'Data.GI.Base.Attributes.:=' value ]
-- @
setItemNumChars :: MonadIO m => Item -> Int32 -> m ()
setItemNumChars :: forall (m :: * -> *). MonadIO m => Item -> Int32 -> m ()
setItemNumChars Item
s Int32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ Item -> (Ptr Item -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Item
s ((Ptr Item -> IO ()) -> IO ()) -> (Ptr Item -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Item
ptr -> do
    Ptr Int32 -> Int32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Item
ptr Ptr Item -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (Int32
val :: Int32)

#if defined(ENABLE_OVERLOADING)
data ItemNumCharsFieldInfo
instance AttrInfo ItemNumCharsFieldInfo where
    type AttrBaseTypeConstraint ItemNumCharsFieldInfo = (~) Item
    type AttrAllowedOps ItemNumCharsFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ItemNumCharsFieldInfo = (~) Int32
    type AttrTransferTypeConstraint ItemNumCharsFieldInfo = (~)Int32
    type AttrTransferType ItemNumCharsFieldInfo = Int32
    type AttrGetType ItemNumCharsFieldInfo = Int32
    type AttrLabel ItemNumCharsFieldInfo = "num_chars"
    type AttrOrigin ItemNumCharsFieldInfo = Item
    attrGet = getItemNumChars
    attrSet = setItemNumChars
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Pango.Structs.Item.numChars"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.25/docs/GI-Pango-Structs-Item.html#g:attr:numChars"
        })

item_numChars :: AttrLabelProxy "numChars"
item_numChars = AttrLabelProxy

#endif


-- | Get the value of the “@analysis@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' item #analysis
-- @
getItemAnalysis :: MonadIO m => Item -> m Pango.Analysis.Analysis
getItemAnalysis :: forall (m :: * -> *). MonadIO m => Item -> m Analysis
getItemAnalysis Item
s = IO Analysis -> m Analysis
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Analysis -> m Analysis) -> IO Analysis -> m Analysis
forall a b. (a -> b) -> a -> b
$ Item -> (Ptr Item -> IO Analysis) -> IO Analysis
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Item
s ((Ptr Item -> IO Analysis) -> IO Analysis)
-> (Ptr Item -> IO Analysis) -> IO Analysis
forall a b. (a -> b) -> a -> b
$ \Ptr Item
ptr -> do
    let val :: Ptr Analysis
val = Ptr Item
ptr Ptr Item -> Int -> Ptr Analysis
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16 :: (Ptr Pango.Analysis.Analysis)
    Analysis
val' <- ((ManagedPtr Analysis -> Analysis) -> Ptr Analysis -> IO Analysis
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr Analysis -> Analysis
Pango.Analysis.Analysis) Ptr Analysis
val
    Analysis -> IO Analysis
forall (m :: * -> *) a. Monad m => a -> m a
return Analysis
val'

#if defined(ENABLE_OVERLOADING)
data ItemAnalysisFieldInfo
instance AttrInfo ItemAnalysisFieldInfo where
    type AttrBaseTypeConstraint ItemAnalysisFieldInfo = (~) Item
    type AttrAllowedOps ItemAnalysisFieldInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint ItemAnalysisFieldInfo = (~) (Ptr Pango.Analysis.Analysis)
    type AttrTransferTypeConstraint ItemAnalysisFieldInfo = (~)(Ptr Pango.Analysis.Analysis)
    type AttrTransferType ItemAnalysisFieldInfo = (Ptr Pango.Analysis.Analysis)
    type AttrGetType ItemAnalysisFieldInfo = Pango.Analysis.Analysis
    type AttrLabel ItemAnalysisFieldInfo = "analysis"
    type AttrOrigin ItemAnalysisFieldInfo = Item
    attrGet = getItemAnalysis
    attrSet = undefined
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Pango.Structs.Item.analysis"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.25/docs/GI-Pango-Structs-Item.html#g:attr:analysis"
        })

item_analysis :: AttrLabelProxy "analysis"
item_analysis = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Item
type instance O.AttributeList Item = ItemAttributeList
type ItemAttributeList = ('[ '("offset", ItemOffsetFieldInfo), '("length", ItemLengthFieldInfo), '("numChars", ItemNumCharsFieldInfo), '("analysis", ItemAnalysisFieldInfo)] :: [(Symbol, *)])
#endif

-- method Item::new
-- method type : Constructor
-- Args: []
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Pango" , name = "Item" })
-- throws : False
-- Skip return : False

foreign import ccall "pango_item_new" pango_item_new :: 
    IO (Ptr Item)

-- | Creates a new @PangoItem@ structure initialized to default values.
itemNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Item
    -- ^ __Returns:__ the newly allocated @PangoItem@, which should
    --   be freed with 'GI.Pango.Structs.Item.itemFree'.
itemNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Item
itemNew  = IO Item -> m Item
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Item -> m Item) -> IO Item -> m Item
forall a b. (a -> b) -> a -> b
$ do
    Ptr Item
result <- IO (Ptr Item)
pango_item_new
    Text -> Ptr Item -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"itemNew" Ptr Item
result
    Item
result' <- ((ManagedPtr Item -> Item) -> Ptr Item -> IO Item
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Item -> Item
Item) Ptr Item
result
    Item -> IO Item
forall (m :: * -> *) a. Monad m => a -> m a
return Item
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method Item::apply_attrs
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "item"
--           , argType = TInterface Name { namespace = "Pango" , name = "Item" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `PangoItem`" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "iter"
--           , argType =
--               TInterface Name { namespace = "Pango" , name = "AttrIterator" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `PangoAttrIterator`"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "pango_item_apply_attrs" pango_item_apply_attrs :: 
    Ptr Item ->                             -- item : TInterface (Name {namespace = "Pango", name = "Item"})
    Ptr Pango.AttrIterator.AttrIterator ->  -- iter : TInterface (Name {namespace = "Pango", name = "AttrIterator"})
    IO ()

-- | Add attributes to a @PangoItem@.
-- 
-- The idea is that you have attributes that don\'t affect itemization,
-- such as font features, so you filter them out using
-- 'GI.Pango.Structs.AttrList.attrListFilter', itemize your text, then reapply the
-- attributes to the resulting items using this function.
-- 
-- The /@iter@/ should be positioned before the range of the item,
-- and will be advanced past it. This function is meant to be called
-- in a loop over the items resulting from itemization, while passing
-- the iter to each call.
-- 
-- /Since: 1.44/
itemApplyAttrs ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Item
    -- ^ /@item@/: a @PangoItem@
    -> Pango.AttrIterator.AttrIterator
    -- ^ /@iter@/: a @PangoAttrIterator@
    -> m ()
itemApplyAttrs :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Item -> AttrIterator -> m ()
itemApplyAttrs Item
item AttrIterator
iter = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Item
item' <- Item -> IO (Ptr Item)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Item
item
    Ptr AttrIterator
iter' <- AttrIterator -> IO (Ptr AttrIterator)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr AttrIterator
iter
    Ptr Item -> Ptr AttrIterator -> IO ()
pango_item_apply_attrs Ptr Item
item' Ptr AttrIterator
iter'
    Item -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Item
item
    AttrIterator -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr AttrIterator
iter
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ItemApplyAttrsMethodInfo
instance (signature ~ (Pango.AttrIterator.AttrIterator -> m ()), MonadIO m) => O.OverloadedMethod ItemApplyAttrsMethodInfo Item signature where
    overloadedMethod = itemApplyAttrs

instance O.OverloadedMethodInfo ItemApplyAttrsMethodInfo Item where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Pango.Structs.Item.itemApplyAttrs",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.25/docs/GI-Pango-Structs-Item.html#v:itemApplyAttrs"
        })


#endif

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

foreign import ccall "pango_item_copy" pango_item_copy :: 
    Ptr Item ->                             -- item : TInterface (Name {namespace = "Pango", name = "Item"})
    IO (Ptr Item)

-- | Copy an existing @PangoItem@ structure.
itemCopy ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Item
    -- ^ /@item@/: a @PangoItem@
    -> m (Maybe Item)
    -- ^ __Returns:__ the newly allocated @PangoItem@
itemCopy :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Item -> m (Maybe Item)
itemCopy Item
item = IO (Maybe Item) -> m (Maybe Item)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Item) -> m (Maybe Item))
-> IO (Maybe Item) -> m (Maybe Item)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Item
item' <- Item -> IO (Ptr Item)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Item
item
    Ptr Item
result <- Ptr Item -> IO (Ptr Item)
pango_item_copy Ptr Item
item'
    Maybe Item
maybeResult <- Ptr Item -> (Ptr Item -> IO Item) -> IO (Maybe Item)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Item
result ((Ptr Item -> IO Item) -> IO (Maybe Item))
-> (Ptr Item -> IO Item) -> IO (Maybe Item)
forall a b. (a -> b) -> a -> b
$ \Ptr Item
result' -> do
        Item
result'' <- ((ManagedPtr Item -> Item) -> Ptr Item -> IO Item
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Item -> Item
Item) Ptr Item
result'
        Item -> IO Item
forall (m :: * -> *) a. Monad m => a -> m a
return Item
result''
    Item -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Item
item
    Maybe Item -> IO (Maybe Item)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Item
maybeResult

#if defined(ENABLE_OVERLOADING)
data ItemCopyMethodInfo
instance (signature ~ (m (Maybe Item)), MonadIO m) => O.OverloadedMethod ItemCopyMethodInfo Item signature where
    overloadedMethod = itemCopy

instance O.OverloadedMethodInfo ItemCopyMethodInfo Item where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Pango.Structs.Item.itemCopy",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.25/docs/GI-Pango-Structs-Item.html#v:itemCopy"
        })


#endif

-- method Item::free
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "item"
--           , argType = TInterface Name { namespace = "Pango" , name = "Item" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `PangoItem`, 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_item_free" pango_item_free :: 
    Ptr Item ->                             -- item : TInterface (Name {namespace = "Pango", name = "Item"})
    IO ()

-- | Free a @PangoItem@ and all associated memory.
itemFree ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Item
    -- ^ /@item@/: a @PangoItem@, may be 'P.Nothing'
    -> m ()
itemFree :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Item -> m ()
itemFree Item
item = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Item
item' <- Item -> IO (Ptr Item)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Item
item
    Ptr Item -> IO ()
pango_item_free Ptr Item
item'
    Item -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Item
item
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ItemFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod ItemFreeMethodInfo Item signature where
    overloadedMethod = itemFree

instance O.OverloadedMethodInfo ItemFreeMethodInfo Item where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Pango.Structs.Item.itemFree",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.25/docs/GI-Pango-Structs-Item.html#v:itemFree"
        })


#endif

-- method Item::split
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "orig"
--           , argType = TInterface Name { namespace = "Pango" , name = "Item" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a `PangoItem`" , 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\n  start of the item"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "split_offset"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "number of chars between start of @orig and @split_index"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Pango" , name = "Item" })
-- throws : False
-- Skip return : False

foreign import ccall "pango_item_split" pango_item_split :: 
    Ptr Item ->                             -- orig : TInterface (Name {namespace = "Pango", name = "Item"})
    Int32 ->                                -- split_index : TBasicType TInt
    Int32 ->                                -- split_offset : TBasicType TInt
    IO (Ptr Item)

-- | 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).
-- /@splitOffset@/ is the length of the first item in chars, and must be
-- provided because the text used to generate the item isn\'t available,
-- so @pango_item_split()@ can\'t count the char length of the split items
-- itself.
itemSplit ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Item
    -- ^ /@orig@/: a @PangoItem@
    -> Int32
    -- ^ /@splitIndex@/: byte index of position to split item, relative to the
    --   start of the item
    -> Int32
    -- ^ /@splitOffset@/: number of chars between start of /@orig@/ and /@splitIndex@/
    -> m Item
    -- ^ __Returns:__ new item representing text before /@splitIndex@/, which
    --   should be freed with 'GI.Pango.Structs.Item.itemFree'.
itemSplit :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Item -> Int32 -> Int32 -> m Item
itemSplit Item
orig Int32
splitIndex Int32
splitOffset = IO Item -> m Item
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Item -> m Item) -> IO Item -> m Item
forall a b. (a -> b) -> a -> b
$ do
    Ptr Item
orig' <- Item -> IO (Ptr Item)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Item
orig
    Ptr Item
result <- Ptr Item -> Int32 -> Int32 -> IO (Ptr Item)
pango_item_split Ptr Item
orig' Int32
splitIndex Int32
splitOffset
    Text -> Ptr Item -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"itemSplit" Ptr Item
result
    Item
result' <- ((ManagedPtr Item -> Item) -> Ptr Item -> IO Item
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Item -> Item
Item) Ptr Item
result
    Item -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Item
orig
    Item -> IO Item
forall (m :: * -> *) a. Monad m => a -> m a
return Item
result'

#if defined(ENABLE_OVERLOADING)
data ItemSplitMethodInfo
instance (signature ~ (Int32 -> Int32 -> m Item), MonadIO m) => O.OverloadedMethod ItemSplitMethodInfo Item signature where
    overloadedMethod = itemSplit

instance O.OverloadedMethodInfo ItemSplitMethodInfo Item where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Pango.Structs.Item.itemSplit",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.25/docs/GI-Pango-Structs-Item.html#v:itemSplit"
        })


#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveItemMethod (t :: Symbol) (o :: *) :: * where
    ResolveItemMethod "applyAttrs" o = ItemApplyAttrsMethodInfo
    ResolveItemMethod "copy" o = ItemCopyMethodInfo
    ResolveItemMethod "free" o = ItemFreeMethodInfo
    ResolveItemMethod "split" o = ItemSplitMethodInfo
    ResolveItemMethod l o = O.MethodResolutionFailed l o

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

#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveItemMethod t Item, O.OverloadedMethod info Item p, R.HasField t Item p) => R.HasField t Item p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveItemMethod t Item, O.OverloadedMethodInfo info Item) => OL.IsLabel t (O.MethodProxy info Item) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif