{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- A t'GI.Poppler.Structs.ImageMapping.ImageMapping' structure represents the location
-- of an image on the page

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

module GI.Poppler.Structs.ImageMapping
    ( 

-- * Exported types
    ImageMapping(..)                        ,
    newZeroImageMapping                     ,


 -- * Methods
-- ** Overloaded methods #method:Overloaded methods#

#if defined(ENABLE_OVERLOADING)
    ResolveImageMappingMethod               ,
#endif


-- ** copy #method:copy#

#if defined(ENABLE_OVERLOADING)
    ImageMappingCopyMethodInfo              ,
#endif
    imageMappingCopy                        ,


-- ** free #method:free#

#if defined(ENABLE_OVERLOADING)
    ImageMappingFreeMethodInfo              ,
#endif
    imageMappingFree                        ,


-- ** new #method:new#

    imageMappingNew                         ,




 -- * Properties
-- ** area #attr:area#
-- | a t'GI.Poppler.Structs.Rectangle.Rectangle' representing an area of the page

    getImageMappingArea                     ,
#if defined(ENABLE_OVERLOADING)
    imageMapping_area                       ,
#endif


-- ** imageId #attr:imageId#
-- | an image identifier

    getImageMappingImageId                  ,
#if defined(ENABLE_OVERLOADING)
    imageMapping_imageId                    ,
#endif
    setImageMappingImageId                  ,




    ) 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.Structs.Rectangle as Poppler.Rectangle

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

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

foreign import ccall "poppler_image_mapping_get_type" c_poppler_image_mapping_get_type :: 
    IO GType

type instance O.ParentTypes ImageMapping = '[]
instance O.HasParentTypes ImageMapping

instance B.Types.TypedObject ImageMapping where
    glibType :: IO GType
glibType = IO GType
c_poppler_image_mapping_get_type

instance B.Types.GBoxed ImageMapping

-- | Convert 'ImageMapping' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue ImageMapping where
    toGValue :: ImageMapping -> IO GValue
toGValue ImageMapping
o = do
        GType
gtype <- IO GType
c_poppler_image_mapping_get_type
        ImageMapping -> (Ptr ImageMapping -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr ImageMapping
o (GType
-> (GValue -> Ptr ImageMapping -> IO ())
-> Ptr ImageMapping
-> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr ImageMapping -> IO ()
forall a. GValue -> Ptr a -> IO ()
B.GValue.set_boxed)
        
    fromGValue :: GValue -> IO ImageMapping
fromGValue GValue
gv = do
        Ptr ImageMapping
ptr <- GValue -> IO (Ptr ImageMapping)
forall b. GValue -> IO (Ptr b)
B.GValue.get_boxed GValue
gv :: IO (Ptr ImageMapping)
        (ManagedPtr ImageMapping -> ImageMapping)
-> Ptr ImageMapping -> IO ImageMapping
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr ImageMapping -> ImageMapping
ImageMapping Ptr ImageMapping
ptr
        
    

-- | Construct a `ImageMapping` struct initialized to zero.
newZeroImageMapping :: MonadIO m => m ImageMapping
newZeroImageMapping :: m ImageMapping
newZeroImageMapping = IO ImageMapping -> m ImageMapping
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ImageMapping -> m ImageMapping)
-> IO ImageMapping -> m ImageMapping
forall a b. (a -> b) -> a -> b
$ Int -> IO (Ptr ImageMapping)
forall a. GBoxed a => Int -> IO (Ptr a)
callocBoxedBytes Int
40 IO (Ptr ImageMapping)
-> (Ptr ImageMapping -> IO ImageMapping) -> IO ImageMapping
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr ImageMapping -> ImageMapping)
-> Ptr ImageMapping -> IO ImageMapping
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr ImageMapping -> ImageMapping
ImageMapping

instance tag ~ 'AttrSet => Constructible ImageMapping tag where
    new :: (ManagedPtr ImageMapping -> ImageMapping)
-> [AttrOp ImageMapping tag] -> m ImageMapping
new ManagedPtr ImageMapping -> ImageMapping
_ [AttrOp ImageMapping tag]
attrs = do
        ImageMapping
o <- m ImageMapping
forall (m :: * -> *). MonadIO m => m ImageMapping
newZeroImageMapping
        ImageMapping -> [AttrOp ImageMapping 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set ImageMapping
o [AttrOp ImageMapping tag]
[AttrOp ImageMapping 'AttrSet]
attrs
        ImageMapping -> m ImageMapping
forall (m :: * -> *) a. Monad m => a -> m a
return ImageMapping
o


-- | 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' imageMapping #area
-- @
getImageMappingArea :: MonadIO m => ImageMapping -> m Poppler.Rectangle.Rectangle
getImageMappingArea :: ImageMapping -> m Rectangle
getImageMappingArea ImageMapping
s = IO Rectangle -> m Rectangle
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Rectangle -> m Rectangle) -> IO Rectangle -> m Rectangle
forall a b. (a -> b) -> a -> b
$ ImageMapping -> (Ptr ImageMapping -> IO Rectangle) -> IO Rectangle
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ImageMapping
s ((Ptr ImageMapping -> IO Rectangle) -> IO Rectangle)
-> (Ptr ImageMapping -> IO Rectangle) -> IO Rectangle
forall a b. (a -> b) -> a -> b
$ \Ptr ImageMapping
ptr -> do
    let val :: Ptr Rectangle
val = Ptr ImageMapping
ptr Ptr ImageMapping -> Int -> Ptr Rectangle
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0 :: (Ptr Poppler.Rectangle.Rectangle)
    Rectangle
val' <- ((ManagedPtr Rectangle -> Rectangle)
-> Ptr Rectangle -> IO Rectangle
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Rectangle -> Rectangle
Poppler.Rectangle.Rectangle) Ptr Rectangle
val
    Rectangle -> IO Rectangle
forall (m :: * -> *) a. Monad m => a -> m a
return Rectangle
val'

#if defined(ENABLE_OVERLOADING)
data ImageMappingAreaFieldInfo
instance AttrInfo ImageMappingAreaFieldInfo where
    type AttrBaseTypeConstraint ImageMappingAreaFieldInfo = (~) ImageMapping
    type AttrAllowedOps ImageMappingAreaFieldInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint ImageMappingAreaFieldInfo = (~) (Ptr Poppler.Rectangle.Rectangle)
    type AttrTransferTypeConstraint ImageMappingAreaFieldInfo = (~)(Ptr Poppler.Rectangle.Rectangle)
    type AttrTransferType ImageMappingAreaFieldInfo = (Ptr Poppler.Rectangle.Rectangle)
    type AttrGetType ImageMappingAreaFieldInfo = Poppler.Rectangle.Rectangle
    type AttrLabel ImageMappingAreaFieldInfo = "area"
    type AttrOrigin ImageMappingAreaFieldInfo = ImageMapping
    attrGet = getImageMappingArea
    attrSet = undefined
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer = undefined

imageMapping_area :: AttrLabelProxy "area"
imageMapping_area = AttrLabelProxy

#endif


-- | Get the value of the “@image_id@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' imageMapping #imageId
-- @
getImageMappingImageId :: MonadIO m => ImageMapping -> m Int32
getImageMappingImageId :: ImageMapping -> m Int32
getImageMappingImageId ImageMapping
s = IO Int32 -> m Int32
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
$ ImageMapping -> (Ptr ImageMapping -> IO Int32) -> IO Int32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ImageMapping
s ((Ptr ImageMapping -> IO Int32) -> IO Int32)
-> (Ptr ImageMapping -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \Ptr ImageMapping
ptr -> do
    Int32
val <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek (Ptr ImageMapping
ptr Ptr ImageMapping -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) :: IO Int32
    Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
val

-- | Set the value of the “@image_id@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' imageMapping [ #imageId 'Data.GI.Base.Attributes.:=' value ]
-- @
setImageMappingImageId :: MonadIO m => ImageMapping -> Int32 -> m ()
setImageMappingImageId :: ImageMapping -> Int32 -> m ()
setImageMappingImageId ImageMapping
s Int32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ImageMapping -> (Ptr ImageMapping -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr ImageMapping
s ((Ptr ImageMapping -> IO ()) -> IO ())
-> (Ptr ImageMapping -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr ImageMapping
ptr -> do
    Ptr Int32 -> Int32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr ImageMapping
ptr Ptr ImageMapping -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) (Int32
val :: Int32)

#if defined(ENABLE_OVERLOADING)
data ImageMappingImageIdFieldInfo
instance AttrInfo ImageMappingImageIdFieldInfo where
    type AttrBaseTypeConstraint ImageMappingImageIdFieldInfo = (~) ImageMapping
    type AttrAllowedOps ImageMappingImageIdFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ImageMappingImageIdFieldInfo = (~) Int32
    type AttrTransferTypeConstraint ImageMappingImageIdFieldInfo = (~)Int32
    type AttrTransferType ImageMappingImageIdFieldInfo = Int32
    type AttrGetType ImageMappingImageIdFieldInfo = Int32
    type AttrLabel ImageMappingImageIdFieldInfo = "image_id"
    type AttrOrigin ImageMappingImageIdFieldInfo = ImageMapping
    attrGet = getImageMappingImageId
    attrSet = setImageMappingImageId
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

imageMapping_imageId :: AttrLabelProxy "imageId"
imageMapping_imageId = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList ImageMapping
type instance O.AttributeList ImageMapping = ImageMappingAttributeList
type ImageMappingAttributeList = ('[ '("area", ImageMappingAreaFieldInfo), '("imageId", ImageMappingImageIdFieldInfo)] :: [(Symbol, *)])
#endif

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

foreign import ccall "poppler_image_mapping_new" poppler_image_mapping_new :: 
    IO (Ptr ImageMapping)

-- | Creates a new t'GI.Poppler.Structs.ImageMapping.ImageMapping'
imageMappingNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m ImageMapping
    -- ^ __Returns:__ a new t'GI.Poppler.Structs.ImageMapping.ImageMapping', use 'GI.Poppler.Structs.ImageMapping.imageMappingFree' to free it
imageMappingNew :: m ImageMapping
imageMappingNew  = IO ImageMapping -> m ImageMapping
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ImageMapping -> m ImageMapping)
-> IO ImageMapping -> m ImageMapping
forall a b. (a -> b) -> a -> b
$ do
    Ptr ImageMapping
result <- IO (Ptr ImageMapping)
poppler_image_mapping_new
    Text -> Ptr ImageMapping -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"imageMappingNew" Ptr ImageMapping
result
    ImageMapping
result' <- ((ManagedPtr ImageMapping -> ImageMapping)
-> Ptr ImageMapping -> IO ImageMapping
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr ImageMapping -> ImageMapping
ImageMapping) Ptr ImageMapping
result
    ImageMapping -> IO ImageMapping
forall (m :: * -> *) a. Monad m => a -> m a
return ImageMapping
result'

#if defined(ENABLE_OVERLOADING)
#endif

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

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

-- | Creates a copy of /@mapping@/
imageMappingCopy ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    ImageMapping
    -- ^ /@mapping@/: a t'GI.Poppler.Structs.ImageMapping.ImageMapping' to copy
    -> m ImageMapping
    -- ^ __Returns:__ a new allocated copy of /@mapping@/
imageMappingCopy :: ImageMapping -> m ImageMapping
imageMappingCopy ImageMapping
mapping = IO ImageMapping -> m ImageMapping
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ImageMapping -> m ImageMapping)
-> IO ImageMapping -> m ImageMapping
forall a b. (a -> b) -> a -> b
$ do
    Ptr ImageMapping
mapping' <- ImageMapping -> IO (Ptr ImageMapping)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr ImageMapping
mapping
    Ptr ImageMapping
result <- Ptr ImageMapping -> IO (Ptr ImageMapping)
poppler_image_mapping_copy Ptr ImageMapping
mapping'
    Text -> Ptr ImageMapping -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"imageMappingCopy" Ptr ImageMapping
result
    ImageMapping
result' <- ((ManagedPtr ImageMapping -> ImageMapping)
-> Ptr ImageMapping -> IO ImageMapping
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr ImageMapping -> ImageMapping
ImageMapping) Ptr ImageMapping
result
    ImageMapping -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr ImageMapping
mapping
    ImageMapping -> IO ImageMapping
forall (m :: * -> *) a. Monad m => a -> m a
return ImageMapping
result'

#if defined(ENABLE_OVERLOADING)
data ImageMappingCopyMethodInfo
instance (signature ~ (m ImageMapping), MonadIO m) => O.MethodInfo ImageMappingCopyMethodInfo ImageMapping signature where
    overloadedMethod = imageMappingCopy

#endif

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

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

-- | Frees the given t'GI.Poppler.Structs.ImageMapping.ImageMapping'
imageMappingFree ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    ImageMapping
    -- ^ /@mapping@/: a t'GI.Poppler.Structs.ImageMapping.ImageMapping'
    -> m ()
imageMappingFree :: ImageMapping -> m ()
imageMappingFree ImageMapping
mapping = 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 ImageMapping
mapping' <- ImageMapping -> IO (Ptr ImageMapping)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr ImageMapping
mapping
    Ptr ImageMapping -> IO ()
poppler_image_mapping_free Ptr ImageMapping
mapping'
    ImageMapping -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr ImageMapping
mapping
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ImageMappingFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo ImageMappingFreeMethodInfo ImageMapping signature where
    overloadedMethod = imageMappingFree

#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveImageMappingMethod (t :: Symbol) (o :: *) :: * where
    ResolveImageMappingMethod "copy" o = ImageMappingCopyMethodInfo
    ResolveImageMappingMethod "free" o = ImageMappingFreeMethodInfo
    ResolveImageMappingMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveImageMappingMethod t ImageMapping, O.MethodInfo info ImageMapping p) => OL.IsLabel t (ImageMapping -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#endif