{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- /No description available in the introspection data./

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

module GI.Poppler.Structs.StructureElementIter
    ( 

-- * Exported types
    StructureElementIter(..)                ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [copy]("GI.Poppler.Structs.StructureElementIter#g:method:copy"), [free]("GI.Poppler.Structs.StructureElementIter#g:method:free"), [next]("GI.Poppler.Structs.StructureElementIter#g:method:next").
-- 
-- ==== Getters
-- [getChild]("GI.Poppler.Structs.StructureElementIter#g:method:getChild"), [getElement]("GI.Poppler.Structs.StructureElementIter#g:method:getElement").
-- 
-- ==== Setters
-- /None/.

#if defined(ENABLE_OVERLOADING)
    ResolveStructureElementIterMethod       ,
#endif

-- ** copy #method:copy#

#if defined(ENABLE_OVERLOADING)
    StructureElementIterCopyMethodInfo      ,
#endif
    structureElementIterCopy                ,


-- ** free #method:free#

#if defined(ENABLE_OVERLOADING)
    StructureElementIterFreeMethodInfo      ,
#endif
    structureElementIterFree                ,


-- ** getChild #method:getChild#

#if defined(ENABLE_OVERLOADING)
    StructureElementIterGetChildMethodInfo  ,
#endif
    structureElementIterGetChild            ,


-- ** getElement #method:getElement#

#if defined(ENABLE_OVERLOADING)
    StructureElementIterGetElementMethodInfo,
#endif
    structureElementIterGetElement          ,


-- ** new #method:new#

    structureElementIterNew                 ,


-- ** next #method:next#

#if defined(ENABLE_OVERLOADING)
    StructureElementIterNextMethodInfo      ,
#endif
    structureElementIterNext                ,




    ) 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.GHashTable as B.GHT
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.Kind as DK
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 qualified Data.Word as DW
import qualified Data.Int as DI
import qualified System.Posix.Types as SPT
import qualified Foreign.C.Types as FCT

-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
#if MIN_VERSION_base(4,18,0)
import qualified GI.Cairo.Structs.Context as Cairo.Context
import qualified GI.Cairo.Structs.Region as Cairo.Region
import qualified GI.Cairo.Structs.Surface as Cairo.Surface
import qualified GI.GLib.Structs.Bytes as GLib.Bytes
import qualified GI.GLib.Structs.DateTime as GLib.DateTime
import qualified GI.GLib.Structs.String as GLib.String
import qualified GI.GLib.Structs.Tree as GLib.Tree
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gio.Callbacks as Gio.Callbacks
import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult
import qualified GI.Gio.Interfaces.File as Gio.File
import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable
import qualified GI.Gio.Objects.InputStream as Gio.InputStream
import qualified GI.Poppler.Callbacks as Poppler.Callbacks
import {-# SOURCE #-} qualified GI.Poppler.Enums as Poppler.Enums
import {-# SOURCE #-} qualified GI.Poppler.Flags as Poppler.Flags
import {-# SOURCE #-} qualified GI.Poppler.Objects.Annot as Poppler.Annot
import {-# SOURCE #-} qualified GI.Poppler.Objects.Attachment as Poppler.Attachment
import {-# SOURCE #-} qualified GI.Poppler.Objects.Document as Poppler.Document
import {-# SOURCE #-} qualified GI.Poppler.Objects.FormField as Poppler.FormField
import {-# SOURCE #-} qualified GI.Poppler.Objects.Layer as Poppler.Layer
import {-# SOURCE #-} qualified GI.Poppler.Objects.Media as Poppler.Media
import {-# SOURCE #-} qualified GI.Poppler.Objects.Movie as Poppler.Movie
import {-# SOURCE #-} qualified GI.Poppler.Objects.PSFile as Poppler.PSFile
import {-# SOURCE #-} qualified GI.Poppler.Objects.Page as Poppler.Page
import {-# SOURCE #-} qualified GI.Poppler.Objects.StructureElement as Poppler.StructureElement
import {-# SOURCE #-} qualified GI.Poppler.Structs.ActionAny as Poppler.ActionAny
import {-# SOURCE #-} qualified GI.Poppler.Structs.ActionGotoDest as Poppler.ActionGotoDest
import {-# SOURCE #-} qualified GI.Poppler.Structs.ActionGotoRemote as Poppler.ActionGotoRemote
import {-# SOURCE #-} qualified GI.Poppler.Structs.ActionJavascript as Poppler.ActionJavascript
import {-# SOURCE #-} qualified GI.Poppler.Structs.ActionLaunch as Poppler.ActionLaunch
import {-# SOURCE #-} qualified GI.Poppler.Structs.ActionLayer as Poppler.ActionLayer
import {-# SOURCE #-} qualified GI.Poppler.Structs.ActionMovie as Poppler.ActionMovie
import {-# SOURCE #-} qualified GI.Poppler.Structs.ActionNamed as Poppler.ActionNamed
import {-# SOURCE #-} qualified GI.Poppler.Structs.ActionOCGState as Poppler.ActionOCGState
import {-# SOURCE #-} qualified GI.Poppler.Structs.ActionRendition as Poppler.ActionRendition
import {-# SOURCE #-} qualified GI.Poppler.Structs.ActionResetForm as Poppler.ActionResetForm
import {-# SOURCE #-} qualified GI.Poppler.Structs.ActionUri as Poppler.ActionUri
import {-# SOURCE #-} qualified GI.Poppler.Structs.AnnotMapping as Poppler.AnnotMapping
import {-# SOURCE #-} qualified GI.Poppler.Structs.CertificateInfo as Poppler.CertificateInfo
import {-# SOURCE #-} qualified GI.Poppler.Structs.Color as Poppler.Color
import {-# SOURCE #-} qualified GI.Poppler.Structs.Dest as Poppler.Dest
import {-# SOURCE #-} qualified GI.Poppler.Structs.FormFieldMapping as Poppler.FormFieldMapping
import {-# SOURCE #-} qualified GI.Poppler.Structs.ImageMapping as Poppler.ImageMapping
import {-# SOURCE #-} qualified GI.Poppler.Structs.LinkMapping as Poppler.LinkMapping
import {-# SOURCE #-} qualified GI.Poppler.Structs.PageRange as Poppler.PageRange
import {-# SOURCE #-} qualified GI.Poppler.Structs.PageTransition as Poppler.PageTransition
import {-# SOURCE #-} qualified GI.Poppler.Structs.Rectangle as Poppler.Rectangle
import {-# SOURCE #-} qualified GI.Poppler.Structs.SignatureInfo as Poppler.SignatureInfo
import {-# SOURCE #-} qualified GI.Poppler.Structs.SigningData as Poppler.SigningData
import {-# SOURCE #-} qualified GI.Poppler.Structs.TextAttributes as Poppler.TextAttributes
import {-# SOURCE #-} qualified GI.Poppler.Structs.TextSpan as Poppler.TextSpan
import {-# SOURCE #-} qualified GI.Poppler.Unions.Action as Poppler.Action

#else
import {-# SOURCE #-} qualified GI.Poppler.Objects.Document as Poppler.Document
import {-# SOURCE #-} qualified GI.Poppler.Objects.StructureElement as Poppler.StructureElement

#endif

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

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

foreign import ccall "poppler_structure_element_iter_get_type" c_poppler_structure_element_iter_get_type :: 
    IO GType

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

instance B.Types.TypedObject StructureElementIter where
    glibType :: IO GType
glibType = IO GType
c_poppler_structure_element_iter_get_type

instance B.Types.GBoxed StructureElementIter

-- | Convert 'StructureElementIter' 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 StructureElementIter) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_poppler_structure_element_iter_get_type
    gvalueSet_ :: Ptr GValue -> Maybe StructureElementIter -> IO ()
gvalueSet_ Ptr GValue
gv Maybe StructureElementIter
P.Nothing = Ptr GValue -> Ptr StructureElementIter -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (Ptr StructureElementIter
forall a. Ptr a
FP.nullPtr :: FP.Ptr StructureElementIter)
    gvalueSet_ Ptr GValue
gv (P.Just StructureElementIter
obj) = StructureElementIter
-> (Ptr StructureElementIter -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr StructureElementIter
obj (Ptr GValue -> Ptr StructureElementIter -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe StructureElementIter)
gvalueGet_ Ptr GValue
gv = do
        Ptr StructureElementIter
ptr <- Ptr GValue -> IO (Ptr StructureElementIter)
forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr StructureElementIter)
        if Ptr StructureElementIter
ptr Ptr StructureElementIter -> Ptr StructureElementIter -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr StructureElementIter
forall a. Ptr a
FP.nullPtr
        then StructureElementIter -> Maybe StructureElementIter
forall a. a -> Maybe a
P.Just (StructureElementIter -> Maybe StructureElementIter)
-> IO StructureElementIter -> IO (Maybe StructureElementIter)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr StructureElementIter -> StructureElementIter)
-> Ptr StructureElementIter -> IO StructureElementIter
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr StructureElementIter -> StructureElementIter
StructureElementIter Ptr StructureElementIter
ptr
        else Maybe StructureElementIter -> IO (Maybe StructureElementIter)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe StructureElementIter
forall a. Maybe a
P.Nothing
        
    


#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList StructureElementIter
type instance O.AttributeList StructureElementIter = StructureElementIterAttributeList
type StructureElementIterAttributeList = ('[ ] :: [(Symbol, DK.Type)])
#endif

-- method StructureElementIter::new
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "poppler_document"
--           , argType =
--               TInterface Name { namespace = "Poppler" , name = "Document" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #PopplerDocument."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "Poppler" , name = "StructureElementIter" })
-- throws : False
-- Skip return : False

foreign import ccall "poppler_structure_element_iter_new" poppler_structure_element_iter_new :: 
    Ptr Poppler.Document.Document ->        -- poppler_document : TInterface (Name {namespace = "Poppler", name = "Document"})
    IO (Ptr StructureElementIter)

-- | Returns the root t'GI.Poppler.Structs.StructureElementIter.StructureElementIter' for /@document@/, or 'P.Nothing'. The
-- returned value must be freed with 'GI.Poppler.Structs.StructureElementIter.structureElementIterFree'.
-- 
-- Documents may have an associated structure tree &mdash;mostly, Tagged-PDF
-- compliant documents&mdash; which can be used to obtain information about
-- the document structure and its contents. Each node in the tree contains
-- a t'GI.Poppler.Objects.StructureElement.StructureElement'.
-- 
-- Here is a simple example that walks the whole tree:
-- 
-- \<informalexample>\<programlisting>
-- static void
-- walk_structure (PopplerStructureElementIter *iter)
-- {
--   do {
--     \/\<!-- -->* Get the element and do something with it *\<!-- -->\/
--     PopplerStructureElementIter *child = poppler_structure_element_iter_get_child (iter);
--     if (child)
--       walk_structure (child);
--     poppler_structure_element_iter_free (child);
--   } while (poppler_structure_element_iter_next (iter));
-- }
-- ...
-- {
--   iter = poppler_structure_element_iter_new (document);
--   walk_structure (iter);
--   poppler_structure_element_iter_free (iter);
-- }
-- \<\/programlisting>\<\/informalexample>
-- 
-- /Since: 0.26/
structureElementIterNew ::
    (B.CallStack.HasCallStack, MonadIO m, Poppler.Document.IsDocument a) =>
    a
    -- ^ /@popplerDocument@/: a t'GI.Poppler.Objects.Document.Document'.
    -> m StructureElementIter
    -- ^ __Returns:__ a new t'GI.Poppler.Structs.StructureElementIter.StructureElementIter', or 'P.Nothing' if document
    --    doesn\'t have structure tree.
structureElementIterNew :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDocument a) =>
a -> m StructureElementIter
structureElementIterNew a
popplerDocument = IO StructureElementIter -> m StructureElementIter
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO StructureElementIter -> m StructureElementIter)
-> IO StructureElementIter -> m StructureElementIter
forall a b. (a -> b) -> a -> b
$ do
    Ptr Document
popplerDocument' <- a -> IO (Ptr Document)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
popplerDocument
    Ptr StructureElementIter
result <- Ptr Document -> IO (Ptr StructureElementIter)
poppler_structure_element_iter_new Ptr Document
popplerDocument'
    Text -> Ptr StructureElementIter -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"structureElementIterNew" Ptr StructureElementIter
result
    StructureElementIter
result' <- ((ManagedPtr StructureElementIter -> StructureElementIter)
-> Ptr StructureElementIter -> IO StructureElementIter
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr StructureElementIter -> StructureElementIter
StructureElementIter) Ptr StructureElementIter
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
popplerDocument
    StructureElementIter -> IO StructureElementIter
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return StructureElementIter
result'

#if defined(ENABLE_OVERLOADING)
#endif

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

foreign import ccall "poppler_structure_element_iter_copy" poppler_structure_element_iter_copy :: 
    Ptr StructureElementIter ->             -- iter : TInterface (Name {namespace = "Poppler", name = "StructureElementIter"})
    IO (Ptr StructureElementIter)

-- | Creates a new t'GI.Poppler.Structs.StructureElementIter.StructureElementIter' as a copy of /@iter@/. The
-- returned value must be freed with 'GI.Poppler.Structs.StructureElementIter.structureElementIterFree'.
-- 
-- /Since: 0.26/
structureElementIterCopy ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    StructureElementIter
    -- ^ /@iter@/: a t'GI.Poppler.Structs.StructureElementIter.StructureElementIter'
    -> m StructureElementIter
    -- ^ __Returns:__ a new t'GI.Poppler.Structs.StructureElementIter.StructureElementIter'
structureElementIterCopy :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
StructureElementIter -> m StructureElementIter
structureElementIterCopy StructureElementIter
iter = IO StructureElementIter -> m StructureElementIter
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO StructureElementIter -> m StructureElementIter)
-> IO StructureElementIter -> m StructureElementIter
forall a b. (a -> b) -> a -> b
$ do
    Ptr StructureElementIter
iter' <- StructureElementIter -> IO (Ptr StructureElementIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr StructureElementIter
iter
    Ptr StructureElementIter
result <- Ptr StructureElementIter -> IO (Ptr StructureElementIter)
poppler_structure_element_iter_copy Ptr StructureElementIter
iter'
    Text -> Ptr StructureElementIter -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"structureElementIterCopy" Ptr StructureElementIter
result
    StructureElementIter
result' <- ((ManagedPtr StructureElementIter -> StructureElementIter)
-> Ptr StructureElementIter -> IO StructureElementIter
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr StructureElementIter -> StructureElementIter
StructureElementIter) Ptr StructureElementIter
result
    StructureElementIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr StructureElementIter
iter
    StructureElementIter -> IO StructureElementIter
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return StructureElementIter
result'

#if defined(ENABLE_OVERLOADING)
data StructureElementIterCopyMethodInfo
instance (signature ~ (m StructureElementIter), MonadIO m) => O.OverloadedMethod StructureElementIterCopyMethodInfo StructureElementIter signature where
    overloadedMethod = structureElementIterCopy

instance O.OverloadedMethodInfo StructureElementIterCopyMethodInfo StructureElementIter where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Structs.StructureElementIter.structureElementIterCopy",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.30/docs/GI-Poppler-Structs-StructureElementIter.html#v:structureElementIterCopy"
        })


#endif

-- method StructureElementIter::free
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "iter"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "StructureElementIter" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #PopplerStructureElementIter"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "poppler_structure_element_iter_free" poppler_structure_element_iter_free :: 
    Ptr StructureElementIter ->             -- iter : TInterface (Name {namespace = "Poppler", name = "StructureElementIter"})
    IO ()

-- | Frees /@iter@/.
-- 
-- /Since: 0.26/
structureElementIterFree ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    StructureElementIter
    -- ^ /@iter@/: a t'GI.Poppler.Structs.StructureElementIter.StructureElementIter'
    -> m ()
structureElementIterFree :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
StructureElementIter -> m ()
structureElementIterFree StructureElementIter
iter = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr StructureElementIter
iter' <- StructureElementIter -> IO (Ptr StructureElementIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr StructureElementIter
iter
    Ptr StructureElementIter -> IO ()
poppler_structure_element_iter_free Ptr StructureElementIter
iter'
    StructureElementIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr StructureElementIter
iter
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data StructureElementIterFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod StructureElementIterFreeMethodInfo StructureElementIter signature where
    overloadedMethod = structureElementIterFree

instance O.OverloadedMethodInfo StructureElementIterFreeMethodInfo StructureElementIter where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Structs.StructureElementIter.structureElementIterFree",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.30/docs/GI-Poppler-Structs-StructureElementIter.html#v:structureElementIterFree"
        })


#endif

-- method StructureElementIter::get_child
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "parent"
--           , argType =
--               TInterface
--                 Name { namespace = "Poppler" , name = "StructureElementIter" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #PopplerStructureElementIter"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "Poppler" , name = "StructureElementIter" })
-- throws : False
-- Skip return : False

foreign import ccall "poppler_structure_element_iter_get_child" poppler_structure_element_iter_get_child :: 
    Ptr StructureElementIter ->             -- parent : TInterface (Name {namespace = "Poppler", name = "StructureElementIter"})
    IO (Ptr StructureElementIter)

-- | Returns a new iterator to the children elements of the
-- t'GI.Poppler.Objects.StructureElement.StructureElement' associated with /@iter@/. The returned value must
-- be freed with 'GI.Poppler.Structs.StructureElementIter.structureElementIterFree'.
-- 
-- /Since: 0.26/
structureElementIterGetChild ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    StructureElementIter
    -- ^ /@parent@/: a t'GI.Poppler.Structs.StructureElementIter.StructureElementIter'
    -> m StructureElementIter
    -- ^ __Returns:__ a new t'GI.Poppler.Structs.StructureElementIter.StructureElementIter'
structureElementIterGetChild :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
StructureElementIter -> m StructureElementIter
structureElementIterGetChild StructureElementIter
parent = IO StructureElementIter -> m StructureElementIter
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO StructureElementIter -> m StructureElementIter)
-> IO StructureElementIter -> m StructureElementIter
forall a b. (a -> b) -> a -> b
$ do
    Ptr StructureElementIter
parent' <- StructureElementIter -> IO (Ptr StructureElementIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr StructureElementIter
parent
    Ptr StructureElementIter
result <- Ptr StructureElementIter -> IO (Ptr StructureElementIter)
poppler_structure_element_iter_get_child Ptr StructureElementIter
parent'
    Text -> Ptr StructureElementIter -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"structureElementIterGetChild" Ptr StructureElementIter
result
    StructureElementIter
result' <- ((ManagedPtr StructureElementIter -> StructureElementIter)
-> Ptr StructureElementIter -> IO StructureElementIter
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr StructureElementIter -> StructureElementIter
StructureElementIter) Ptr StructureElementIter
result
    StructureElementIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr StructureElementIter
parent
    StructureElementIter -> IO StructureElementIter
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return StructureElementIter
result'

#if defined(ENABLE_OVERLOADING)
data StructureElementIterGetChildMethodInfo
instance (signature ~ (m StructureElementIter), MonadIO m) => O.OverloadedMethod StructureElementIterGetChildMethodInfo StructureElementIter signature where
    overloadedMethod = structureElementIterGetChild

instance O.OverloadedMethodInfo StructureElementIterGetChildMethodInfo StructureElementIter where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Structs.StructureElementIter.structureElementIterGetChild",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.30/docs/GI-Poppler-Structs-StructureElementIter.html#v:structureElementIterGetChild"
        })


#endif

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

foreign import ccall "poppler_structure_element_iter_get_element" poppler_structure_element_iter_get_element :: 
    Ptr StructureElementIter ->             -- iter : TInterface (Name {namespace = "Poppler", name = "StructureElementIter"})
    IO (Ptr Poppler.StructureElement.StructureElement)

-- | Returns the t'GI.Poppler.Structs.StructureElementIter.StructureElementIter' associated with /@iter@/.
-- 
-- /Since: 0.26/
structureElementIterGetElement ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    StructureElementIter
    -- ^ /@iter@/: a t'GI.Poppler.Structs.StructureElementIter.StructureElementIter'
    -> m Poppler.StructureElement.StructureElement
    -- ^ __Returns:__ a new t'GI.Poppler.Structs.StructureElementIter.StructureElementIter'
structureElementIterGetElement :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
StructureElementIter -> m StructureElement
structureElementIterGetElement StructureElementIter
iter = IO StructureElement -> m StructureElement
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO StructureElement -> m StructureElement)
-> IO StructureElement -> m StructureElement
forall a b. (a -> b) -> a -> b
$ do
    Ptr StructureElementIter
iter' <- StructureElementIter -> IO (Ptr StructureElementIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr StructureElementIter
iter
    Ptr StructureElement
result <- Ptr StructureElementIter -> IO (Ptr StructureElement)
poppler_structure_element_iter_get_element Ptr StructureElementIter
iter'
    Text -> Ptr StructureElement -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"structureElementIterGetElement" Ptr StructureElement
result
    StructureElement
result' <- ((ManagedPtr StructureElement -> StructureElement)
-> Ptr StructureElement -> IO StructureElement
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr StructureElement -> StructureElement
Poppler.StructureElement.StructureElement) Ptr StructureElement
result
    StructureElementIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr StructureElementIter
iter
    StructureElement -> IO StructureElement
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return StructureElement
result'

#if defined(ENABLE_OVERLOADING)
data StructureElementIterGetElementMethodInfo
instance (signature ~ (m Poppler.StructureElement.StructureElement), MonadIO m) => O.OverloadedMethod StructureElementIterGetElementMethodInfo StructureElementIter signature where
    overloadedMethod = structureElementIterGetElement

instance O.OverloadedMethodInfo StructureElementIterGetElementMethodInfo StructureElementIter where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Structs.StructureElementIter.structureElementIterGetElement",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.30/docs/GI-Poppler-Structs-StructureElementIter.html#v:structureElementIterGetElement"
        })


#endif

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

foreign import ccall "poppler_structure_element_iter_next" poppler_structure_element_iter_next :: 
    Ptr StructureElementIter ->             -- iter : TInterface (Name {namespace = "Poppler", name = "StructureElementIter"})
    IO CInt

-- | Sets /@iter@/ to point to the next structure element at the current level
-- of the tree, if valid. See 'GI.Poppler.Structs.StructureElementIter.structureElementIterNew' for more
-- information.
-- 
-- /Since: 0.26/
structureElementIterNext ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    StructureElementIter
    -- ^ /@iter@/: a t'GI.Poppler.Structs.StructureElementIter.StructureElementIter'
    -> m Bool
    -- ^ __Returns:__ 'P.True', if /@iter@/ was set to the next structure element
structureElementIterNext :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
StructureElementIter -> m Bool
structureElementIterNext StructureElementIter
iter = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr StructureElementIter
iter' <- StructureElementIter -> IO (Ptr StructureElementIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr StructureElementIter
iter
    CInt
result <- Ptr StructureElementIter -> IO CInt
poppler_structure_element_iter_next Ptr StructureElementIter
iter'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    StructureElementIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr StructureElementIter
iter
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data StructureElementIterNextMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod StructureElementIterNextMethodInfo StructureElementIter signature where
    overloadedMethod = structureElementIterNext

instance O.OverloadedMethodInfo StructureElementIterNextMethodInfo StructureElementIter where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Structs.StructureElementIter.structureElementIterNext",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.30/docs/GI-Poppler-Structs-StructureElementIter.html#v:structureElementIterNext"
        })


#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveStructureElementIterMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveStructureElementIterMethod "copy" o = StructureElementIterCopyMethodInfo
    ResolveStructureElementIterMethod "free" o = StructureElementIterFreeMethodInfo
    ResolveStructureElementIterMethod "next" o = StructureElementIterNextMethodInfo
    ResolveStructureElementIterMethod "getChild" o = StructureElementIterGetChildMethodInfo
    ResolveStructureElementIterMethod "getElement" o = StructureElementIterGetElementMethodInfo
    ResolveStructureElementIterMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveStructureElementIterMethod t StructureElementIter, O.OverloadedMethod info StructureElementIter p) => OL.IsLabel t (StructureElementIter -> 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 ~ ResolveStructureElementIterMethod t StructureElementIter, O.OverloadedMethod info StructureElementIter p, R.HasField t StructureElementIter p) => R.HasField t StructureElementIter p where
    getField = O.overloadedMethod @info

#endif

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

#endif