{-# 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.Objects.Layer
    ( 

-- * Exported types
    Layer(..)                               ,
    IsLayer                                 ,
    toLayer                                 ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [hide]("GI.Poppler.Objects.Layer#g:method:hide"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [isParent]("GI.Poppler.Objects.Layer#g:method:isParent"), [isVisible]("GI.Poppler.Objects.Layer#g:method:isVisible"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [show]("GI.Poppler.Objects.Layer#g:method:show"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getData]("GI.GObject.Objects.Object#g:method:getData"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getRadioButtonGroupId]("GI.Poppler.Objects.Layer#g:method:getRadioButtonGroupId"), [getTitle]("GI.Poppler.Objects.Layer#g:method:getTitle").
-- 
-- ==== Setters
-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty").

#if defined(ENABLE_OVERLOADING)
    ResolveLayerMethod                      ,
#endif

-- ** getRadioButtonGroupId #method:getRadioButtonGroupId#

#if defined(ENABLE_OVERLOADING)
    LayerGetRadioButtonGroupIdMethodInfo    ,
#endif
    layerGetRadioButtonGroupId              ,


-- ** getTitle #method:getTitle#

#if defined(ENABLE_OVERLOADING)
    LayerGetTitleMethodInfo                 ,
#endif
    layerGetTitle                           ,


-- ** hide #method:hide#

#if defined(ENABLE_OVERLOADING)
    LayerHideMethodInfo                     ,
#endif
    layerHide                               ,


-- ** isParent #method:isParent#

#if defined(ENABLE_OVERLOADING)
    LayerIsParentMethodInfo                 ,
#endif
    layerIsParent                           ,


-- ** isVisible #method:isVisible#

#if defined(ENABLE_OVERLOADING)
    LayerIsVisibleMethodInfo                ,
#endif
    layerIsVisible                          ,


-- ** show #method:show#

#if defined(ENABLE_OVERLOADING)
    LayerShowMethodInfo                     ,
#endif
    layerShow                               ,




    ) 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 GI.GObject.Objects.Object as GObject.Object

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

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

foreign import ccall "poppler_layer_get_type"
    c_poppler_layer_get_type :: IO B.Types.GType

instance B.Types.TypedObject Layer where
    glibType :: IO GType
glibType = IO GType
c_poppler_layer_get_type

instance B.Types.GObject Layer

-- | Type class for types which can be safely cast to `Layer`, for instance with `toLayer`.
class (SP.GObject o, O.IsDescendantOf Layer o) => IsLayer o
instance (SP.GObject o, O.IsDescendantOf Layer o) => IsLayer o

instance O.HasParentTypes Layer
type instance O.ParentTypes Layer = '[GObject.Object.Object]

-- | Cast to `Layer`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toLayer :: (MIO.MonadIO m, IsLayer o) => o -> m Layer
toLayer :: forall (m :: * -> *) o. (MonadIO m, IsLayer o) => o -> m Layer
toLayer = IO Layer -> m Layer
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Layer -> m Layer) -> (o -> IO Layer) -> o -> m Layer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr Layer -> Layer) -> o -> IO Layer
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
 ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr Layer -> Layer
Layer

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

#if defined(ENABLE_OVERLOADING)
type family ResolveLayerMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveLayerMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveLayerMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveLayerMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveLayerMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveLayerMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveLayerMethod "hide" o = LayerHideMethodInfo
    ResolveLayerMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveLayerMethod "isParent" o = LayerIsParentMethodInfo
    ResolveLayerMethod "isVisible" o = LayerIsVisibleMethodInfo
    ResolveLayerMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveLayerMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveLayerMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveLayerMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveLayerMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveLayerMethod "show" o = LayerShowMethodInfo
    ResolveLayerMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveLayerMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveLayerMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveLayerMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveLayerMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveLayerMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveLayerMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveLayerMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveLayerMethod "getRadioButtonGroupId" o = LayerGetRadioButtonGroupIdMethodInfo
    ResolveLayerMethod "getTitle" o = LayerGetTitleMethodInfo
    ResolveLayerMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveLayerMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveLayerMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveLayerMethod l o = O.MethodResolutionFailed l o

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

#endif

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

#endif

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

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Layer = LayerSignalList
type LayerSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)])

#endif

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

foreign import ccall "poppler_layer_get_radio_button_group_id" poppler_layer_get_radio_button_group_id :: 
    Ptr Layer ->                            -- layer : TInterface (Name {namespace = "Poppler", name = "Layer"})
    IO Int32

-- | Returns the numeric ID the radio button group associated with /@layer@/.
-- 
-- /Since: 0.12/
layerGetRadioButtonGroupId ::
    (B.CallStack.HasCallStack, MonadIO m, IsLayer a) =>
    a
    -- ^ /@layer@/: a t'GI.Poppler.Objects.Layer.Layer'
    -> m Int32
    -- ^ __Returns:__ the ID of the radio button group associated with /@layer@/,
    -- or 0 if the layer is not associated to any radio button group
layerGetRadioButtonGroupId :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsLayer a) =>
a -> m Int32
layerGetRadioButtonGroupId a
layer = IO Int32 -> m Int32
forall a. IO a -> m a
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
$ do
    Ptr Layer
layer' <- a -> IO (Ptr Layer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
layer
    Int32
result <- Ptr Layer -> IO Int32
poppler_layer_get_radio_button_group_id Ptr Layer
layer'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
layer
    Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

#if defined(ENABLE_OVERLOADING)
data LayerGetRadioButtonGroupIdMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsLayer a) => O.OverloadedMethod LayerGetRadioButtonGroupIdMethodInfo a signature where
    overloadedMethod = layerGetRadioButtonGroupId

instance O.OverloadedMethodInfo LayerGetRadioButtonGroupIdMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Objects.Layer.layerGetRadioButtonGroupId",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.29/docs/GI-Poppler-Objects-Layer.html#v:layerGetRadioButtonGroupId"
        })


#endif

-- method Layer::get_title
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "layer"
--           , argType =
--               TInterface Name { namespace = "Poppler" , name = "Layer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #PopplerLayer" , 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_layer_get_title" poppler_layer_get_title :: 
    Ptr Layer ->                            -- layer : TInterface (Name {namespace = "Poppler", name = "Layer"})
    IO CString

-- | Returns the name of the layer suitable for
-- presentation as a title in a viewer\'s GUI
-- 
-- /Since: 0.12/
layerGetTitle ::
    (B.CallStack.HasCallStack, MonadIO m, IsLayer a) =>
    a
    -- ^ /@layer@/: a t'GI.Poppler.Objects.Layer.Layer'
    -> m T.Text
    -- ^ __Returns:__ a string containing the title of the layer
layerGetTitle :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsLayer a) =>
a -> m Text
layerGetTitle a
layer = IO Text -> m Text
forall a. IO a -> m a
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 Layer
layer' <- a -> IO (Ptr Layer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
layer
    CString
result <- Ptr Layer -> IO CString
poppler_layer_get_title Ptr Layer
layer'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"layerGetTitle" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
layer
    Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data LayerGetTitleMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsLayer a) => O.OverloadedMethod LayerGetTitleMethodInfo a signature where
    overloadedMethod = layerGetTitle

instance O.OverloadedMethodInfo LayerGetTitleMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Objects.Layer.layerGetTitle",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.29/docs/GI-Poppler-Objects-Layer.html#v:layerGetTitle"
        })


#endif

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

foreign import ccall "poppler_layer_hide" poppler_layer_hide :: 
    Ptr Layer ->                            -- layer : TInterface (Name {namespace = "Poppler", name = "Layer"})
    IO ()

-- | Hides /@layer@/. If /@layer@/ is the parent of other nested layers,
-- such layers will be also hidden and will be blocked until /@layer@/
-- is shown again
-- 
-- /Since: 0.12/
layerHide ::
    (B.CallStack.HasCallStack, MonadIO m, IsLayer a) =>
    a
    -- ^ /@layer@/: a t'GI.Poppler.Objects.Layer.Layer'
    -> m ()
layerHide :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsLayer a) =>
a -> m ()
layerHide a
layer = 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 Layer
layer' <- a -> IO (Ptr Layer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
layer
    Ptr Layer -> IO ()
poppler_layer_hide Ptr Layer
layer'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
layer
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data LayerHideMethodInfo
instance (signature ~ (m ()), MonadIO m, IsLayer a) => O.OverloadedMethod LayerHideMethodInfo a signature where
    overloadedMethod = layerHide

instance O.OverloadedMethodInfo LayerHideMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Objects.Layer.layerHide",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.29/docs/GI-Poppler-Objects-Layer.html#v:layerHide"
        })


#endif

-- method Layer::is_parent
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "layer"
--           , argType =
--               TInterface Name { namespace = "Poppler" , name = "Layer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #PopplerLayer" , 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_layer_is_parent" poppler_layer_is_parent :: 
    Ptr Layer ->                            -- layer : TInterface (Name {namespace = "Poppler", name = "Layer"})
    IO CInt

-- | Returns whether /@layer@/ is parent of other nested layers.
-- 
-- /Since: 0.12/
layerIsParent ::
    (B.CallStack.HasCallStack, MonadIO m, IsLayer a) =>
    a
    -- ^ /@layer@/: a t'GI.Poppler.Objects.Layer.Layer'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@layer@/ is a parent layer
layerIsParent :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsLayer a) =>
a -> m Bool
layerIsParent a
layer = 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 Layer
layer' <- a -> IO (Ptr Layer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
layer
    CInt
result <- Ptr Layer -> IO CInt
poppler_layer_is_parent Ptr Layer
layer'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
layer
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data LayerIsParentMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsLayer a) => O.OverloadedMethod LayerIsParentMethodInfo a signature where
    overloadedMethod = layerIsParent

instance O.OverloadedMethodInfo LayerIsParentMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Objects.Layer.layerIsParent",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.29/docs/GI-Poppler-Objects-Layer.html#v:layerIsParent"
        })


#endif

-- method Layer::is_visible
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "layer"
--           , argType =
--               TInterface Name { namespace = "Poppler" , name = "Layer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #PopplerLayer" , 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_layer_is_visible" poppler_layer_is_visible :: 
    Ptr Layer ->                            -- layer : TInterface (Name {namespace = "Poppler", name = "Layer"})
    IO CInt

-- | Returns whether /@layer@/ is visible
-- 
-- /Since: 0.12/
layerIsVisible ::
    (B.CallStack.HasCallStack, MonadIO m, IsLayer a) =>
    a
    -- ^ /@layer@/: a t'GI.Poppler.Objects.Layer.Layer'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@layer@/ is visible
layerIsVisible :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsLayer a) =>
a -> m Bool
layerIsVisible a
layer = 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 Layer
layer' <- a -> IO (Ptr Layer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
layer
    CInt
result <- Ptr Layer -> IO CInt
poppler_layer_is_visible Ptr Layer
layer'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
layer
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data LayerIsVisibleMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsLayer a) => O.OverloadedMethod LayerIsVisibleMethodInfo a signature where
    overloadedMethod = layerIsVisible

instance O.OverloadedMethodInfo LayerIsVisibleMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Objects.Layer.layerIsVisible",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.29/docs/GI-Poppler-Objects-Layer.html#v:layerIsVisible"
        })


#endif

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

foreign import ccall "poppler_layer_show" poppler_layer_show :: 
    Ptr Layer ->                            -- layer : TInterface (Name {namespace = "Poppler", name = "Layer"})
    IO ()

-- | Shows /@layer@/
-- 
-- /Since: 0.12/
layerShow ::
    (B.CallStack.HasCallStack, MonadIO m, IsLayer a) =>
    a
    -- ^ /@layer@/: a t'GI.Poppler.Objects.Layer.Layer'
    -> m ()
layerShow :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsLayer a) =>
a -> m ()
layerShow a
layer = 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 Layer
layer' <- a -> IO (Ptr Layer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
layer
    Ptr Layer -> IO ()
poppler_layer_show Ptr Layer
layer'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
layer
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data LayerShowMethodInfo
instance (signature ~ (m ()), MonadIO m, IsLayer a) => O.OverloadedMethod LayerShowMethodInfo a signature where
    overloadedMethod = layerShow

instance O.OverloadedMethodInfo LayerShowMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Objects.Layer.layerShow",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.29/docs/GI-Poppler-Objects-Layer.html#v:layerShow"
        })


#endif