LayersIter.hs


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

/No description available in the introspection data./
-}

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

module GI.Poppler.Structs.LayersIter
    ( 

-- * Exported types
    LayersIter(..)                          ,
    noLayersIter                            ,


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

#if ENABLE_OVERLOADING
    LayersIterCopyMethodInfo                ,
#endif
    layersIterCopy                          ,


-- ** free #method:free#

#if ENABLE_OVERLOADING
    LayersIterFreeMethodInfo                ,
#endif
    layersIterFree                          ,


-- ** getChild #method:getChild#

#if ENABLE_OVERLOADING
    LayersIterGetChildMethodInfo            ,
#endif
    layersIterGetChild                      ,


-- ** getLayer #method:getLayer#

#if ENABLE_OVERLOADING
    LayersIterGetLayerMethodInfo            ,
#endif
    layersIterGetLayer                      ,


-- ** getTitle #method:getTitle#

#if ENABLE_OVERLOADING
    LayersIterGetTitleMethodInfo            ,
#endif
    layersIterGetTitle                      ,


-- ** new #method:new#

    layersIterNew                           ,


-- ** next #method:next#

#if ENABLE_OVERLOADING
    LayersIterNextMethodInfo                ,
#endif
    layersIterNext                          ,




    ) 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.Poppler.Objects.Document as Poppler.Document
import {-# SOURCE #-} qualified GI.Poppler.Objects.Layer as Poppler.Layer

-- | Memory-managed wrapper type.
newtype LayersIter = LayersIter (ManagedPtr LayersIter)
foreign import ccall "poppler_layers_iter_get_type" c_poppler_layers_iter_get_type :: 
    IO GType

instance BoxedObject LayersIter where
    boxedType _ = c_poppler_layers_iter_get_type

-- | A convenience alias for `Nothing` :: `Maybe` `LayersIter`.
noLayersIter :: Maybe LayersIter
noLayersIter = Nothing


#if ENABLE_OVERLOADING
instance O.HasAttributeList LayersIter
type instance O.AttributeList LayersIter = LayersIterAttributeList
type LayersIterAttributeList = ('[ ] :: [(Symbol, *)])
#endif

-- method LayersIter::new
-- method type : Constructor
-- Args : [Arg {argCName = "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, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "LayersIter"}))
-- throws : False
-- Skip return : False

foreign import ccall "poppler_layers_iter_new" poppler_layers_iter_new :: 
    Ptr Poppler.Document.Document ->        -- document : TInterface (Name {namespace = "Poppler", name = "Document"})
    IO (Ptr LayersIter)

{- |
/No description available in the introspection data./

/Since: 0.12/
-}
layersIterNew ::
    (B.CallStack.HasCallStack, MonadIO m, Poppler.Document.IsDocument a) =>
    a
    {- ^ /@document@/: a 'GI.Poppler.Objects.Document.Document' -}
    -> m LayersIter
layersIterNew document = liftIO $ do
    document' <- unsafeManagedPtrCastPtr document
    result <- poppler_layers_iter_new document'
    checkUnexpectedReturnNULL "layersIterNew" result
    result' <- (wrapBoxed LayersIter) result
    touchManagedPtr document
    return result'

#if ENABLE_OVERLOADING
#endif

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

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

{- |
Creates a new 'GI.Poppler.Structs.LayersIter.LayersIter' as a copy of /@iter@/.  This must be freed with
'GI.Poppler.Structs.LayersIter.layersIterFree'.
-}
layersIterCopy ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    LayersIter
    {- ^ /@iter@/: a 'GI.Poppler.Structs.LayersIter.LayersIter' -}
    -> m LayersIter
    {- ^ __Returns:__ a new 'GI.Poppler.Structs.LayersIter.LayersIter'

Since 0.12 -}
layersIterCopy iter = liftIO $ do
    iter' <- unsafeManagedPtrGetPtr iter
    result <- poppler_layers_iter_copy iter'
    checkUnexpectedReturnNULL "layersIterCopy" result
    result' <- (wrapBoxed LayersIter) result
    touchManagedPtr iter
    return result'

#if ENABLE_OVERLOADING
data LayersIterCopyMethodInfo
instance (signature ~ (m LayersIter), MonadIO m) => O.MethodInfo LayersIterCopyMethodInfo LayersIter signature where
    overloadedMethod _ = layersIterCopy

#endif

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

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

{- |
Frees /@iter@/.

/Since: 0.12/
-}
layersIterFree ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    LayersIter
    {- ^ /@iter@/: a 'GI.Poppler.Structs.LayersIter.LayersIter' -}
    -> m ()
layersIterFree iter = liftIO $ do
    iter' <- unsafeManagedPtrGetPtr iter
    poppler_layers_iter_free iter'
    touchManagedPtr iter
    return ()

#if ENABLE_OVERLOADING
data LayersIterFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo LayersIterFreeMethodInfo LayersIter signature where
    overloadedMethod _ = layersIterFree

#endif

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

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

{- |
Returns a newly created child of /@parent@/, or 'Nothing' if the iter has no child.
See 'GI.Poppler.Structs.LayersIter.layersIterNew' for more information on this function.

/Since: 0.12/
-}
layersIterGetChild ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    LayersIter
    {- ^ /@parent@/: a 'GI.Poppler.Structs.LayersIter.LayersIter' -}
    -> m LayersIter
    {- ^ __Returns:__ a new 'GI.Poppler.Structs.LayersIter.LayersIter', or 'Nothing' -}
layersIterGetChild parent = liftIO $ do
    parent' <- unsafeManagedPtrGetPtr parent
    result <- poppler_layers_iter_get_child parent'
    checkUnexpectedReturnNULL "layersIterGetChild" result
    result' <- (wrapBoxed LayersIter) result
    touchManagedPtr parent
    return result'

#if ENABLE_OVERLOADING
data LayersIterGetChildMethodInfo
instance (signature ~ (m LayersIter), MonadIO m) => O.MethodInfo LayersIterGetChildMethodInfo LayersIter signature where
    overloadedMethod _ = layersIterGetChild

#endif

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

foreign import ccall "poppler_layers_iter_get_layer" poppler_layers_iter_get_layer :: 
    Ptr LayersIter ->                       -- iter : TInterface (Name {namespace = "Poppler", name = "LayersIter"})
    IO (Ptr Poppler.Layer.Layer)

{- |
Returns the 'GI.Poppler.Objects.Layer.Layer' associated with /@iter@/.

/Since: 0.12/
-}
layersIterGetLayer ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    LayersIter
    {- ^ /@iter@/: a 'GI.Poppler.Structs.LayersIter.LayersIter' -}
    -> m Poppler.Layer.Layer
    {- ^ __Returns:__ a new 'GI.Poppler.Objects.Layer.Layer', or 'Nothing' if
there isn\'t any layer associated with /@iter@/ -}
layersIterGetLayer iter = liftIO $ do
    iter' <- unsafeManagedPtrGetPtr iter
    result <- poppler_layers_iter_get_layer iter'
    checkUnexpectedReturnNULL "layersIterGetLayer" result
    result' <- (wrapObject Poppler.Layer.Layer) result
    touchManagedPtr iter
    return result'

#if ENABLE_OVERLOADING
data LayersIterGetLayerMethodInfo
instance (signature ~ (m Poppler.Layer.Layer), MonadIO m) => O.MethodInfo LayersIterGetLayerMethodInfo LayersIter signature where
    overloadedMethod _ = layersIterGetLayer

#endif

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

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

{- |
Returns the title associated with /@iter@/.  It must be freed with
'GI.GLib.Functions.free'.

/Since: 0.12/
-}
layersIterGetTitle ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    LayersIter
    {- ^ /@iter@/: a 'GI.Poppler.Structs.LayersIter.LayersIter' -}
    -> m T.Text
    {- ^ __Returns:__ a new string containing the /@iter@/\'s title or 'Nothing' if /@iter@/ doesn\'t have a title.
The returned string should be freed with 'GI.GLib.Functions.free' when no longer needed. -}
layersIterGetTitle iter = liftIO $ do
    iter' <- unsafeManagedPtrGetPtr iter
    result <- poppler_layers_iter_get_title iter'
    checkUnexpectedReturnNULL "layersIterGetTitle" result
    result' <- cstringToText result
    freeMem result
    touchManagedPtr iter
    return result'

#if ENABLE_OVERLOADING
data LayersIterGetTitleMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo LayersIterGetTitleMethodInfo LayersIter signature where
    overloadedMethod _ = layersIterGetTitle

#endif

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

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

{- |
Sets /@iter@/ to point to the next action at the current level, if valid.  See
'GI.Poppler.Structs.LayersIter.layersIterNew' for more information.

/Since: 0.12/
-}
layersIterNext ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    LayersIter
    {- ^ /@iter@/: a 'GI.Poppler.Structs.LayersIter.LayersIter' -}
    -> m Bool
    {- ^ __Returns:__ 'True', if /@iter@/ was set to the next action -}
layersIterNext iter = liftIO $ do
    iter' <- unsafeManagedPtrGetPtr iter
    result <- poppler_layers_iter_next iter'
    let result' = (/= 0) result
    touchManagedPtr iter
    return result'

#if ENABLE_OVERLOADING
data LayersIterNextMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo LayersIterNextMethodInfo LayersIter signature where
    overloadedMethod _ = layersIterNext

#endif

#if ENABLE_OVERLOADING
type family ResolveLayersIterMethod (t :: Symbol) (o :: *) :: * where
    ResolveLayersIterMethod "copy" o = LayersIterCopyMethodInfo
    ResolveLayersIterMethod "free" o = LayersIterFreeMethodInfo
    ResolveLayersIterMethod "next" o = LayersIterNextMethodInfo
    ResolveLayersIterMethod "getChild" o = LayersIterGetChildMethodInfo
    ResolveLayersIterMethod "getLayer" o = LayersIterGetLayerMethodInfo
    ResolveLayersIterMethod "getTitle" o = LayersIterGetTitleMethodInfo
    ResolveLayersIterMethod l o = O.MethodResolutionFailed l o

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