{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Poppler.Structs.LayersIter
(
LayersIter(..) ,
#if defined(ENABLE_OVERLOADING)
ResolveLayersIterMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
LayersIterCopyMethodInfo ,
#endif
layersIterCopy ,
#if defined(ENABLE_OVERLOADING)
LayersIterFreeMethodInfo ,
#endif
layersIterFree ,
#if defined(ENABLE_OVERLOADING)
LayersIterGetChildMethodInfo ,
#endif
layersIterGetChild ,
#if defined(ENABLE_OVERLOADING)
LayersIterGetLayerMethodInfo ,
#endif
layersIterGetLayer ,
#if defined(ENABLE_OVERLOADING)
LayersIterGetTitleMethodInfo ,
#endif
layersIterGetTitle ,
layersIterNew ,
#if defined(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.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.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
newtype LayersIter = LayersIter (SP.ManagedPtr LayersIter)
deriving (LayersIter -> LayersIter -> Bool
(LayersIter -> LayersIter -> Bool)
-> (LayersIter -> LayersIter -> Bool) -> Eq LayersIter
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: LayersIter -> LayersIter -> Bool
$c/= :: LayersIter -> LayersIter -> Bool
== :: LayersIter -> LayersIter -> Bool
$c== :: LayersIter -> LayersIter -> Bool
Eq)
instance SP.ManagedPtrNewtype LayersIter where
toManagedPtr :: LayersIter -> ManagedPtr LayersIter
toManagedPtr (LayersIter ManagedPtr LayersIter
p) = ManagedPtr LayersIter
p
foreign import ccall "poppler_layers_iter_get_type" c_poppler_layers_iter_get_type ::
IO GType
type instance O.ParentTypes LayersIter = '[]
instance O.HasParentTypes LayersIter
instance B.Types.TypedObject LayersIter where
glibType :: IO GType
glibType = IO GType
c_poppler_layers_iter_get_type
instance B.Types.GBoxed LayersIter
instance B.GValue.IsGValue LayersIter where
toGValue :: LayersIter -> IO GValue
toGValue LayersIter
o = do
GType
gtype <- IO GType
c_poppler_layers_iter_get_type
LayersIter -> (Ptr LayersIter -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr LayersIter
o (GType
-> (GValue -> Ptr LayersIter -> IO ())
-> Ptr LayersIter
-> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr LayersIter -> IO ()
forall a. GValue -> Ptr a -> IO ()
B.GValue.set_boxed)
fromGValue :: GValue -> IO LayersIter
fromGValue GValue
gv = do
Ptr LayersIter
ptr <- GValue -> IO (Ptr LayersIter)
forall b. GValue -> IO (Ptr b)
B.GValue.get_boxed GValue
gv :: IO (Ptr LayersIter)
(ManagedPtr LayersIter -> LayersIter)
-> Ptr LayersIter -> IO LayersIter
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr LayersIter -> LayersIter
LayersIter Ptr LayersIter
ptr
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList LayersIter
type instance O.AttributeList LayersIter = LayersIterAttributeList
type LayersIterAttributeList = ('[ ] :: [(Symbol, *)])
#endif
foreign import ccall "poppler_layers_iter_new" poppler_layers_iter_new ::
Ptr Poppler.Document.Document ->
IO (Ptr LayersIter)
layersIterNew ::
(B.CallStack.HasCallStack, MonadIO m, Poppler.Document.IsDocument a) =>
a
-> m LayersIter
layersIterNew :: a -> m LayersIter
layersIterNew a
document = IO LayersIter -> m LayersIter
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO LayersIter -> m LayersIter) -> IO LayersIter -> m LayersIter
forall a b. (a -> b) -> a -> b
$ do
Ptr Document
document' <- a -> IO (Ptr Document)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
document
Ptr LayersIter
result <- Ptr Document -> IO (Ptr LayersIter)
poppler_layers_iter_new Ptr Document
document'
Text -> Ptr LayersIter -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"layersIterNew" Ptr LayersIter
result
LayersIter
result' <- ((ManagedPtr LayersIter -> LayersIter)
-> Ptr LayersIter -> IO LayersIter
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr LayersIter -> LayersIter
LayersIter) Ptr LayersIter
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
document
LayersIter -> IO LayersIter
forall (m :: * -> *) a. Monad m => a -> m a
return LayersIter
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "poppler_layers_iter_copy" poppler_layers_iter_copy ::
Ptr LayersIter ->
IO (Ptr LayersIter)
layersIterCopy ::
(B.CallStack.HasCallStack, MonadIO m) =>
LayersIter
-> m LayersIter
layersIterCopy :: LayersIter -> m LayersIter
layersIterCopy LayersIter
iter = IO LayersIter -> m LayersIter
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO LayersIter -> m LayersIter) -> IO LayersIter -> m LayersIter
forall a b. (a -> b) -> a -> b
$ do
Ptr LayersIter
iter' <- LayersIter -> IO (Ptr LayersIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr LayersIter
iter
Ptr LayersIter
result <- Ptr LayersIter -> IO (Ptr LayersIter)
poppler_layers_iter_copy Ptr LayersIter
iter'
Text -> Ptr LayersIter -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"layersIterCopy" Ptr LayersIter
result
LayersIter
result' <- ((ManagedPtr LayersIter -> LayersIter)
-> Ptr LayersIter -> IO LayersIter
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr LayersIter -> LayersIter
LayersIter) Ptr LayersIter
result
LayersIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr LayersIter
iter
LayersIter -> IO LayersIter
forall (m :: * -> *) a. Monad m => a -> m a
return LayersIter
result'
#if defined(ENABLE_OVERLOADING)
data LayersIterCopyMethodInfo
instance (signature ~ (m LayersIter), MonadIO m) => O.MethodInfo LayersIterCopyMethodInfo LayersIter signature where
overloadedMethod = layersIterCopy
#endif
foreign import ccall "poppler_layers_iter_free" poppler_layers_iter_free ::
Ptr LayersIter ->
IO ()
layersIterFree ::
(B.CallStack.HasCallStack, MonadIO m) =>
LayersIter
-> m ()
layersIterFree :: LayersIter -> m ()
layersIterFree LayersIter
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 LayersIter
iter' <- LayersIter -> IO (Ptr LayersIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr LayersIter
iter
Ptr LayersIter -> IO ()
poppler_layers_iter_free Ptr LayersIter
iter'
LayersIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr LayersIter
iter
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data LayersIterFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo LayersIterFreeMethodInfo LayersIter signature where
overloadedMethod = layersIterFree
#endif
foreign import ccall "poppler_layers_iter_get_child" poppler_layers_iter_get_child ::
Ptr LayersIter ->
IO (Ptr LayersIter)
layersIterGetChild ::
(B.CallStack.HasCallStack, MonadIO m) =>
LayersIter
-> m LayersIter
layersIterGetChild :: LayersIter -> m LayersIter
layersIterGetChild LayersIter
parent = IO LayersIter -> m LayersIter
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO LayersIter -> m LayersIter) -> IO LayersIter -> m LayersIter
forall a b. (a -> b) -> a -> b
$ do
Ptr LayersIter
parent' <- LayersIter -> IO (Ptr LayersIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr LayersIter
parent
Ptr LayersIter
result <- Ptr LayersIter -> IO (Ptr LayersIter)
poppler_layers_iter_get_child Ptr LayersIter
parent'
Text -> Ptr LayersIter -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"layersIterGetChild" Ptr LayersIter
result
LayersIter
result' <- ((ManagedPtr LayersIter -> LayersIter)
-> Ptr LayersIter -> IO LayersIter
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr LayersIter -> LayersIter
LayersIter) Ptr LayersIter
result
LayersIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr LayersIter
parent
LayersIter -> IO LayersIter
forall (m :: * -> *) a. Monad m => a -> m a
return LayersIter
result'
#if defined(ENABLE_OVERLOADING)
data LayersIterGetChildMethodInfo
instance (signature ~ (m LayersIter), MonadIO m) => O.MethodInfo LayersIterGetChildMethodInfo LayersIter signature where
overloadedMethod = layersIterGetChild
#endif
foreign import ccall "poppler_layers_iter_get_layer" poppler_layers_iter_get_layer ::
Ptr LayersIter ->
IO (Ptr Poppler.Layer.Layer)
layersIterGetLayer ::
(B.CallStack.HasCallStack, MonadIO m) =>
LayersIter
-> m Poppler.Layer.Layer
layersIterGetLayer :: LayersIter -> m Layer
layersIterGetLayer LayersIter
iter = IO Layer -> m Layer
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Layer -> m Layer) -> IO Layer -> m Layer
forall a b. (a -> b) -> a -> b
$ do
Ptr LayersIter
iter' <- LayersIter -> IO (Ptr LayersIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr LayersIter
iter
Ptr Layer
result <- Ptr LayersIter -> IO (Ptr Layer)
poppler_layers_iter_get_layer Ptr LayersIter
iter'
Text -> Ptr Layer -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"layersIterGetLayer" Ptr Layer
result
Layer
result' <- ((ManagedPtr Layer -> Layer) -> Ptr Layer -> IO Layer
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Layer -> Layer
Poppler.Layer.Layer) Ptr Layer
result
LayersIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr LayersIter
iter
Layer -> IO Layer
forall (m :: * -> *) a. Monad m => a -> m a
return Layer
result'
#if defined(ENABLE_OVERLOADING)
data LayersIterGetLayerMethodInfo
instance (signature ~ (m Poppler.Layer.Layer), MonadIO m) => O.MethodInfo LayersIterGetLayerMethodInfo LayersIter signature where
overloadedMethod = layersIterGetLayer
#endif
foreign import ccall "poppler_layers_iter_get_title" poppler_layers_iter_get_title ::
Ptr LayersIter ->
IO CString
layersIterGetTitle ::
(B.CallStack.HasCallStack, MonadIO m) =>
LayersIter
-> m T.Text
layersIterGetTitle :: LayersIter -> m Text
layersIterGetTitle LayersIter
iter = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
Ptr LayersIter
iter' <- LayersIter -> IO (Ptr LayersIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr LayersIter
iter
CString
result <- Ptr LayersIter -> IO CString
poppler_layers_iter_get_title Ptr LayersIter
iter'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"layersIterGetTitle" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
LayersIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr LayersIter
iter
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data LayersIterGetTitleMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo LayersIterGetTitleMethodInfo LayersIter signature where
overloadedMethod = layersIterGetTitle
#endif
foreign import ccall "poppler_layers_iter_next" poppler_layers_iter_next ::
Ptr LayersIter ->
IO CInt
layersIterNext ::
(B.CallStack.HasCallStack, MonadIO m) =>
LayersIter
-> m Bool
layersIterNext :: LayersIter -> m Bool
layersIterNext LayersIter
iter = IO Bool -> m Bool
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 LayersIter
iter' <- LayersIter -> IO (Ptr LayersIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr LayersIter
iter
CInt
result <- Ptr LayersIter -> IO CInt
poppler_layers_iter_next Ptr LayersIter
iter'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
LayersIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr LayersIter
iter
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data LayersIterNextMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo LayersIterNextMethodInfo LayersIter signature where
overloadedMethod = layersIterNext
#endif
#if defined(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 @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#endif