{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- A t'GI.Poppler.Structs.FormFieldMapping.FormFieldMapping' structure represents the location
-- of /@field@/ on the page

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

module GI.Poppler.Structs.FormFieldMapping
    ( 

-- * Exported types
    FormFieldMapping(..)                    ,
    newZeroFormFieldMapping                 ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [copy]("GI.Poppler.Structs.FormFieldMapping#g:method:copy"), [free]("GI.Poppler.Structs.FormFieldMapping#g:method:free").
-- 
-- ==== Getters
-- /None/.
-- 
-- ==== Setters
-- /None/.

#if defined(ENABLE_OVERLOADING)
    ResolveFormFieldMappingMethod           ,
#endif

-- ** copy #method:copy#

#if defined(ENABLE_OVERLOADING)
    FormFieldMappingCopyMethodInfo          ,
#endif
    formFieldMappingCopy                    ,


-- ** free #method:free#

#if defined(ENABLE_OVERLOADING)
    FormFieldMappingFreeMethodInfo          ,
#endif
    formFieldMappingFree                    ,


-- ** new #method:new#

    formFieldMappingNew                     ,




 -- * Properties


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

#if defined(ENABLE_OVERLOADING)
    formFieldMapping_area                   ,
#endif
    getFormFieldMappingArea                 ,


-- ** field #attr:field#
-- | a t'GI.Poppler.Objects.FormField.FormField'

    clearFormFieldMappingField              ,
#if defined(ENABLE_OVERLOADING)
    formFieldMapping_field                  ,
#endif
    getFormFieldMappingField                ,
    setFormFieldMappingField                ,




    ) 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 {-# SOURCE #-} qualified GI.Poppler.Objects.FormField as Poppler.FormField
import {-# SOURCE #-} qualified GI.Poppler.Structs.Rectangle as Poppler.Rectangle

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

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

foreign import ccall "poppler_form_field_mapping_get_type" c_poppler_form_field_mapping_get_type :: 
    IO GType

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

instance B.Types.TypedObject FormFieldMapping where
    glibType :: IO GType
glibType = IO GType
c_poppler_form_field_mapping_get_type

instance B.Types.GBoxed FormFieldMapping

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

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

instance tag ~ 'AttrSet => Constructible FormFieldMapping tag where
    new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr FormFieldMapping -> FormFieldMapping)
-> [AttrOp FormFieldMapping tag] -> m FormFieldMapping
new ManagedPtr FormFieldMapping -> FormFieldMapping
_ [AttrOp FormFieldMapping tag]
attrs = do
        FormFieldMapping
o <- m FormFieldMapping
forall (m :: * -> *). MonadIO m => m FormFieldMapping
newZeroFormFieldMapping
        FormFieldMapping -> [AttrOp FormFieldMapping 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set FormFieldMapping
o [AttrOp FormFieldMapping tag]
[AttrOp FormFieldMapping 'AttrSet]
attrs
        FormFieldMapping -> m FormFieldMapping
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return FormFieldMapping
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' formFieldMapping #area
-- @
getFormFieldMappingArea :: MonadIO m => FormFieldMapping -> m Poppler.Rectangle.Rectangle
getFormFieldMappingArea :: forall (m :: * -> *). MonadIO m => FormFieldMapping -> m Rectangle
getFormFieldMappingArea FormFieldMapping
s = IO Rectangle -> m Rectangle
forall a. IO a -> m a
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
$ FormFieldMapping
-> (Ptr FormFieldMapping -> IO Rectangle) -> IO Rectangle
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr FormFieldMapping
s ((Ptr FormFieldMapping -> IO Rectangle) -> IO Rectangle)
-> (Ptr FormFieldMapping -> IO Rectangle) -> IO Rectangle
forall a b. (a -> b) -> a -> b
$ \Ptr FormFieldMapping
ptr -> do
    let val :: Ptr Rectangle
val = Ptr FormFieldMapping
ptr Ptr FormFieldMapping -> 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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Rectangle
val'

#if defined(ENABLE_OVERLOADING)
data FormFieldMappingAreaFieldInfo
instance AttrInfo FormFieldMappingAreaFieldInfo where
    type AttrBaseTypeConstraint FormFieldMappingAreaFieldInfo = (~) FormFieldMapping
    type AttrAllowedOps FormFieldMappingAreaFieldInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint FormFieldMappingAreaFieldInfo = (~) (Ptr Poppler.Rectangle.Rectangle)
    type AttrTransferTypeConstraint FormFieldMappingAreaFieldInfo = (~)(Ptr Poppler.Rectangle.Rectangle)
    type AttrTransferType FormFieldMappingAreaFieldInfo = (Ptr Poppler.Rectangle.Rectangle)
    type AttrGetType FormFieldMappingAreaFieldInfo = Poppler.Rectangle.Rectangle
    type AttrLabel FormFieldMappingAreaFieldInfo = "area"
    type AttrOrigin FormFieldMappingAreaFieldInfo = FormFieldMapping
    attrGet = getFormFieldMappingArea
    attrSet = undefined
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Structs.FormFieldMapping.area"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.29/docs/GI-Poppler-Structs-FormFieldMapping.html#g:attr:area"
        })

formFieldMapping_area :: AttrLabelProxy "area"
formFieldMapping_area = AttrLabelProxy

#endif


-- | Get the value of the “@field@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' formFieldMapping #field
-- @
getFormFieldMappingField :: MonadIO m => FormFieldMapping -> m (Maybe Poppler.FormField.FormField)
getFormFieldMappingField :: forall (m :: * -> *).
MonadIO m =>
FormFieldMapping -> m (Maybe FormField)
getFormFieldMappingField FormFieldMapping
s = IO (Maybe FormField) -> m (Maybe FormField)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe FormField) -> m (Maybe FormField))
-> IO (Maybe FormField) -> m (Maybe FormField)
forall a b. (a -> b) -> a -> b
$ FormFieldMapping
-> (Ptr FormFieldMapping -> IO (Maybe FormField))
-> IO (Maybe FormField)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr FormFieldMapping
s ((Ptr FormFieldMapping -> IO (Maybe FormField))
 -> IO (Maybe FormField))
-> (Ptr FormFieldMapping -> IO (Maybe FormField))
-> IO (Maybe FormField)
forall a b. (a -> b) -> a -> b
$ \Ptr FormFieldMapping
ptr -> do
    Ptr FormField
val <- Ptr (Ptr FormField) -> IO (Ptr FormField)
forall a. Storable a => Ptr a -> IO a
peek (Ptr FormFieldMapping
ptr Ptr FormFieldMapping -> Int -> Ptr (Ptr FormField)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) :: IO (Ptr Poppler.FormField.FormField)
    Maybe FormField
result <- Ptr FormField
-> (Ptr FormField -> IO FormField) -> IO (Maybe FormField)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr FormField
val ((Ptr FormField -> IO FormField) -> IO (Maybe FormField))
-> (Ptr FormField -> IO FormField) -> IO (Maybe FormField)
forall a b. (a -> b) -> a -> b
$ \Ptr FormField
val' -> do
        FormField
val'' <- ((ManagedPtr FormField -> FormField)
-> Ptr FormField -> IO FormField
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr FormField -> FormField
Poppler.FormField.FormField) Ptr FormField
val'
        FormField -> IO FormField
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return FormField
val''
    Maybe FormField -> IO (Maybe FormField)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe FormField
result

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

-- | Set the value of the “@field@” 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' #field
-- @
clearFormFieldMappingField :: MonadIO m => FormFieldMapping -> m ()
clearFormFieldMappingField :: forall (m :: * -> *). MonadIO m => FormFieldMapping -> m ()
clearFormFieldMappingField FormFieldMapping
s = 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
$ FormFieldMapping -> (Ptr FormFieldMapping -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr FormFieldMapping
s ((Ptr FormFieldMapping -> IO ()) -> IO ())
-> (Ptr FormFieldMapping -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr FormFieldMapping
ptr -> do
    Ptr (Ptr FormField) -> Ptr FormField -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr FormFieldMapping
ptr Ptr FormFieldMapping -> Int -> Ptr (Ptr FormField)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) (Ptr FormField
forall a. Ptr a
FP.nullPtr :: Ptr Poppler.FormField.FormField)

#if defined(ENABLE_OVERLOADING)
data FormFieldMappingFieldFieldInfo
instance AttrInfo FormFieldMappingFieldFieldInfo where
    type AttrBaseTypeConstraint FormFieldMappingFieldFieldInfo = (~) FormFieldMapping
    type AttrAllowedOps FormFieldMappingFieldFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint FormFieldMappingFieldFieldInfo = (~) (Ptr Poppler.FormField.FormField)
    type AttrTransferTypeConstraint FormFieldMappingFieldFieldInfo = (~)(Ptr Poppler.FormField.FormField)
    type AttrTransferType FormFieldMappingFieldFieldInfo = (Ptr Poppler.FormField.FormField)
    type AttrGetType FormFieldMappingFieldFieldInfo = Maybe Poppler.FormField.FormField
    type AttrLabel FormFieldMappingFieldFieldInfo = "field"
    type AttrOrigin FormFieldMappingFieldFieldInfo = FormFieldMapping
    attrGet = getFormFieldMappingField
    attrSet = setFormFieldMappingField
    attrConstruct = undefined
    attrClear = clearFormFieldMappingField
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Structs.FormFieldMapping.field"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.29/docs/GI-Poppler-Structs-FormFieldMapping.html#g:attr:field"
        })

formFieldMapping_field :: AttrLabelProxy "field"
formFieldMapping_field = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList FormFieldMapping
type instance O.AttributeList FormFieldMapping = FormFieldMappingAttributeList
type FormFieldMappingAttributeList = ('[ '("area", FormFieldMappingAreaFieldInfo), '("field", FormFieldMappingFieldFieldInfo)] :: [(Symbol, DK.Type)])
#endif

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

foreign import ccall "poppler_form_field_mapping_new" poppler_form_field_mapping_new :: 
    IO (Ptr FormFieldMapping)

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

#if defined(ENABLE_OVERLOADING)
#endif

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

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

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

#if defined(ENABLE_OVERLOADING)
data FormFieldMappingCopyMethodInfo
instance (signature ~ (m FormFieldMapping), MonadIO m) => O.OverloadedMethod FormFieldMappingCopyMethodInfo FormFieldMapping signature where
    overloadedMethod = formFieldMappingCopy

instance O.OverloadedMethodInfo FormFieldMappingCopyMethodInfo FormFieldMapping where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Structs.FormFieldMapping.formFieldMappingCopy",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.29/docs/GI-Poppler-Structs-FormFieldMapping.html#v:formFieldMappingCopy"
        })


#endif

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

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

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

#if defined(ENABLE_OVERLOADING)
data FormFieldMappingFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod FormFieldMappingFreeMethodInfo FormFieldMapping signature where
    overloadedMethod = formFieldMappingFree

instance O.OverloadedMethodInfo FormFieldMappingFreeMethodInfo FormFieldMapping where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Structs.FormFieldMapping.formFieldMappingFree",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.29/docs/GI-Poppler-Structs-FormFieldMapping.html#v:formFieldMappingFree"
        })


#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveFormFieldMappingMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveFormFieldMappingMethod "copy" o = FormFieldMappingCopyMethodInfo
    ResolveFormFieldMappingMethod "free" o = FormFieldMappingFreeMethodInfo
    ResolveFormFieldMappingMethod l o = O.MethodResolutionFailed l o

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

#endif

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

#endif