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

A 'GI.Poppler.Structs.LinkMapping.LinkMapping' structure represents the location
of /@action@/ on the page
-}

module GI.Poppler.Structs.LinkMapping
    ( 

-- * Exported types
    LinkMapping(..)                         ,
    newZeroLinkMapping                      ,
    noLinkMapping                           ,


 -- * Methods
-- ** copy #method:copy#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    LinkMappingCopyMethodInfo               ,
#endif
    linkMappingCopy                         ,


-- ** free #method:free#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    LinkMappingFreeMethodInfo               ,
#endif
    linkMappingFree                         ,


-- ** new #method:new#
    linkMappingNew                          ,




 -- * Properties
-- ** action #attr:action#
    clearLinkMappingAction                  ,
    getLinkMappingAction                    ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    linkMapping_action                      ,
#endif
    setLinkMappingAction                    ,


-- ** area #attr:area#
    getLinkMappingArea                      ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    linkMapping_area                        ,
#endif




    ) 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.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
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 {-# SOURCE #-} qualified GI.Poppler.Structs.Rectangle as Poppler.Rectangle
import {-# SOURCE #-} qualified GI.Poppler.Unions.Action as Poppler.Action

newtype LinkMapping = LinkMapping (ManagedPtr LinkMapping)
foreign import ccall "poppler_link_mapping_get_type" c_poppler_link_mapping_get_type :: 
    IO GType

instance BoxedObject LinkMapping where
    boxedType _ = c_poppler_link_mapping_get_type

-- | Construct a `LinkMapping` struct initialized to zero.
newZeroLinkMapping :: MonadIO m => m LinkMapping
newZeroLinkMapping = liftIO $ callocBoxedBytes 40 >>= wrapBoxed LinkMapping

instance tag ~ 'AttrSet => Constructible LinkMapping tag where
    new _ attrs = do
        o <- newZeroLinkMapping
        GI.Attributes.set o attrs
        return o


noLinkMapping :: Maybe LinkMapping
noLinkMapping = Nothing

getLinkMappingArea :: MonadIO m => LinkMapping -> m Poppler.Rectangle.Rectangle
getLinkMappingArea s = liftIO $ withManagedPtr s $ \ptr -> do
    let val = ptr `plusPtr` 0 :: (Ptr Poppler.Rectangle.Rectangle)
    val' <- (newBoxed Poppler.Rectangle.Rectangle) val
    return val'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data LinkMappingAreaFieldInfo
instance AttrInfo LinkMappingAreaFieldInfo where
    type AttrAllowedOps LinkMappingAreaFieldInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint LinkMappingAreaFieldInfo = (~) (Ptr Poppler.Rectangle.Rectangle)
    type AttrBaseTypeConstraint LinkMappingAreaFieldInfo = (~) LinkMapping
    type AttrGetType LinkMappingAreaFieldInfo = Poppler.Rectangle.Rectangle
    type AttrLabel LinkMappingAreaFieldInfo = "area"
    type AttrOrigin LinkMappingAreaFieldInfo = LinkMapping
    attrGet _ = getLinkMappingArea
    attrSet _ = undefined
    attrConstruct = undefined
    attrClear _ = undefined

linkMapping_area :: AttrLabelProxy "area"
linkMapping_area = AttrLabelProxy

#endif


getLinkMappingAction :: MonadIO m => LinkMapping -> m (Maybe Poppler.Action.Action)
getLinkMappingAction s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 32) :: IO (Ptr Poppler.Action.Action)
    result <- SP.convertIfNonNull val $ \val' -> do
        val'' <- (newBoxed Poppler.Action.Action) val'
        return val''
    return result

setLinkMappingAction :: MonadIO m => LinkMapping -> Ptr Poppler.Action.Action -> m ()
setLinkMappingAction s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 32) (val :: Ptr Poppler.Action.Action)

clearLinkMappingAction :: MonadIO m => LinkMapping -> m ()
clearLinkMappingAction s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 32) (FP.nullPtr :: Ptr Poppler.Action.Action)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data LinkMappingActionFieldInfo
instance AttrInfo LinkMappingActionFieldInfo where
    type AttrAllowedOps LinkMappingActionFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint LinkMappingActionFieldInfo = (~) (Ptr Poppler.Action.Action)
    type AttrBaseTypeConstraint LinkMappingActionFieldInfo = (~) LinkMapping
    type AttrGetType LinkMappingActionFieldInfo = Maybe Poppler.Action.Action
    type AttrLabel LinkMappingActionFieldInfo = "action"
    type AttrOrigin LinkMappingActionFieldInfo = LinkMapping
    attrGet _ = getLinkMappingAction
    attrSet _ = setLinkMappingAction
    attrConstruct = undefined
    attrClear _ = clearLinkMappingAction

linkMapping_action :: AttrLabelProxy "action"
linkMapping_action = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
instance O.HasAttributeList LinkMapping
type instance O.AttributeList LinkMapping = LinkMappingAttributeList
type LinkMappingAttributeList = ('[ '("area", LinkMappingAreaFieldInfo), '("action", LinkMappingActionFieldInfo)] :: [(Symbol, *)])
#endif

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

foreign import ccall "poppler_link_mapping_new" poppler_link_mapping_new :: 
    IO (Ptr LinkMapping)

{- |
Creates a new 'GI.Poppler.Structs.LinkMapping.LinkMapping'
-}
linkMappingNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m LinkMapping
    {- ^ __Returns:__ a new 'GI.Poppler.Structs.LinkMapping.LinkMapping', use 'GI.Poppler.Structs.LinkMapping.linkMappingFree' to free it -}
linkMappingNew  = liftIO $ do
    result <- poppler_link_mapping_new
    checkUnexpectedReturnNULL "linkMappingNew" result
    result' <- (wrapBoxed LinkMapping) result
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
#endif

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

foreign import ccall "poppler_link_mapping_copy" poppler_link_mapping_copy :: 
    Ptr LinkMapping ->                      -- mapping : TInterface (Name {namespace = "Poppler", name = "LinkMapping"})
    IO (Ptr LinkMapping)

{- |
Creates a copy of /@mapping@/
-}
linkMappingCopy ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    LinkMapping
    {- ^ /@mapping@/: a 'GI.Poppler.Structs.LinkMapping.LinkMapping' to copy -}
    -> m LinkMapping
    {- ^ __Returns:__ a new allocated copy of /@mapping@/ -}
linkMappingCopy mapping = liftIO $ do
    mapping' <- unsafeManagedPtrGetPtr mapping
    result <- poppler_link_mapping_copy mapping'
    checkUnexpectedReturnNULL "linkMappingCopy" result
    result' <- (wrapBoxed LinkMapping) result
    touchManagedPtr mapping
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data LinkMappingCopyMethodInfo
instance (signature ~ (m LinkMapping), MonadIO m) => O.MethodInfo LinkMappingCopyMethodInfo LinkMapping signature where
    overloadedMethod _ = linkMappingCopy

#endif

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

foreign import ccall "poppler_link_mapping_free" poppler_link_mapping_free :: 
    Ptr LinkMapping ->                      -- mapping : TInterface (Name {namespace = "Poppler", name = "LinkMapping"})
    IO ()

{- |
Frees the given 'GI.Poppler.Structs.LinkMapping.LinkMapping'
-}
linkMappingFree ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    LinkMapping
    {- ^ /@mapping@/: a 'GI.Poppler.Structs.LinkMapping.LinkMapping' -}
    -> m ()
linkMappingFree mapping = liftIO $ do
    mapping' <- unsafeManagedPtrGetPtr mapping
    poppler_link_mapping_free mapping'
    touchManagedPtr mapping
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data LinkMappingFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo LinkMappingFreeMethodInfo LinkMapping signature where
    overloadedMethod _ = linkMappingFree

#endif

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
type family ResolveLinkMappingMethod (t :: Symbol) (o :: *) :: * where
    ResolveLinkMappingMethod "copy" o = LinkMappingCopyMethodInfo
    ResolveLinkMappingMethod "free" o = LinkMappingFreeMethodInfo
    ResolveLinkMappingMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveLinkMappingMethod t LinkMapping, O.MethodInfo info LinkMapping p) => O.IsLabelProxy t (LinkMapping -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveLinkMappingMethod t LinkMapping, O.MethodInfo info LinkMapping p) => O.IsLabel t (LinkMapping -> 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

#endif