LinkMapping.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)

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

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

module GI.Poppler.Structs.LinkMapping
    ( 

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


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

#if ENABLE_OVERLOADING
    LinkMappingCopyMethodInfo               ,
#endif
    linkMappingCopy                         ,


-- ** free #method:free#

#if ENABLE_OVERLOADING
    LinkMappingFreeMethodInfo               ,
#endif
    linkMappingFree                         ,


-- ** new #method:new#

    linkMappingNew                          ,




 -- * Properties
-- ** action #attr:action#
{- | a 'GI.Poppler.Unions.Action.Action'
-}
    clearLinkMappingAction                  ,
    getLinkMappingAction                    ,
#if ENABLE_OVERLOADING
    linkMapping_action                      ,
#endif
    setLinkMappingAction                    ,


-- ** area #attr:area#
{- | a 'GI.Poppler.Structs.Rectangle.Rectangle' representing an area of the page
-}
    getLinkMappingArea                      ,
#if ENABLE_OVERLOADING
    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.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.Structs.Rectangle as Poppler.Rectangle
import {-# SOURCE #-} qualified GI.Poppler.Unions.Action as Poppler.Action

-- | Memory-managed wrapper type.
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


-- | A convenience alias for `Nothing` :: `Maybe` `LinkMapping`.
noLinkMapping :: Maybe LinkMapping
noLinkMapping = Nothing

{- |
Get the value of the “@area@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' linkMapping #area
@
-}
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 ENABLE_OVERLOADING
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


{- |
Get the value of the “@action@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' linkMapping #action
@
-}
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

{- |
Set the value of the “@action@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' linkMapping [ #action 'Data.GI.Base.Attributes.:=' value ]
@
-}
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)

{- |
Set the value of the “@action@” field to `Nothing`.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.clear' #action
@
-}
clearLinkMappingAction :: MonadIO m => LinkMapping -> m ()
clearLinkMappingAction s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 32) (FP.nullPtr :: Ptr Poppler.Action.Action)

#if ENABLE_OVERLOADING
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 ENABLE_OVERLOADING
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 ENABLE_OVERLOADING
#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 ENABLE_OVERLOADING
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 ENABLE_OVERLOADING
data LinkMappingFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo LinkMappingFreeMethodInfo LinkMapping signature where
    overloadedMethod _ = linkMappingFree

#endif

#if ENABLE_OVERLOADING
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) => OL.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