{-# 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.Quadrilateral.Quadrilateral' is used to describe rectangle-like polygon
--  with arbitrary inclination on a page.
-- 
--  Since: 0.26

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

module GI.Poppler.Structs.Quadrilateral
    ( 

-- * Exported types
    Quadrilateral(..)                       ,
    newZeroQuadrilateral                    ,


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

#if defined(ENABLE_OVERLOADING)
    ResolveQuadrilateralMethod              ,
#endif


-- ** copy #method:copy#

#if defined(ENABLE_OVERLOADING)
    QuadrilateralCopyMethodInfo             ,
#endif
    quadrilateralCopy                       ,


-- ** free #method:free#

#if defined(ENABLE_OVERLOADING)
    QuadrilateralFreeMethodInfo             ,
#endif
    quadrilateralFree                       ,


-- ** new #method:new#

    quadrilateralNew                        ,




 -- * Properties
-- ** p1 #attr:p1#
-- | a t'GI.Poppler.Structs.Point.Point' with the first vertex coordinates

    getQuadrilateralP1                      ,
#if defined(ENABLE_OVERLOADING)
    quadrilateral_p1                        ,
#endif


-- ** p2 #attr:p2#
-- | a t'GI.Poppler.Structs.Point.Point' with the second vertex coordinates

    getQuadrilateralP2                      ,
#if defined(ENABLE_OVERLOADING)
    quadrilateral_p2                        ,
#endif


-- ** p3 #attr:p3#
-- | a t'GI.Poppler.Structs.Point.Point' with the third vertex coordinates

    getQuadrilateralP3                      ,
#if defined(ENABLE_OVERLOADING)
    quadrilateral_p3                        ,
#endif


-- ** p4 #attr:p4#
-- | a t'GI.Poppler.Structs.Point.Point' with the fourth vertex coordinates

    getQuadrilateralP4                      ,
#if defined(ENABLE_OVERLOADING)
    quadrilateral_p4                        ,
#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.BasicTypes as B.Types
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.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.Point as Poppler.Point

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

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

foreign import ccall "poppler_quadrilateral_get_type" c_poppler_quadrilateral_get_type :: 
    IO GType

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

instance B.Types.TypedObject Quadrilateral where
    glibType :: IO GType
glibType = IO GType
c_poppler_quadrilateral_get_type

instance B.Types.GBoxed Quadrilateral

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

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

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


-- | Get the value of the “@p1@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' quadrilateral #p1
-- @
getQuadrilateralP1 :: MonadIO m => Quadrilateral -> m Poppler.Point.Point
getQuadrilateralP1 :: Quadrilateral -> m Point
getQuadrilateralP1 Quadrilateral
s = IO Point -> m Point
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Point -> m Point) -> IO Point -> m Point
forall a b. (a -> b) -> a -> b
$ Quadrilateral -> (Ptr Quadrilateral -> IO Point) -> IO Point
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Quadrilateral
s ((Ptr Quadrilateral -> IO Point) -> IO Point)
-> (Ptr Quadrilateral -> IO Point) -> IO Point
forall a b. (a -> b) -> a -> b
$ \Ptr Quadrilateral
ptr -> do
    let val :: Ptr Point
val = Ptr Quadrilateral
ptr Ptr Quadrilateral -> Int -> Ptr Point
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0 :: (Ptr Poppler.Point.Point)
    Point
val' <- ((ManagedPtr Point -> Point) -> Ptr Point -> IO Point
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Point -> Point
Poppler.Point.Point) Ptr Point
val
    Point -> IO Point
forall (m :: * -> *) a. Monad m => a -> m a
return Point
val'

#if defined(ENABLE_OVERLOADING)
data QuadrilateralP1FieldInfo
instance AttrInfo QuadrilateralP1FieldInfo where
    type AttrBaseTypeConstraint QuadrilateralP1FieldInfo = (~) Quadrilateral
    type AttrAllowedOps QuadrilateralP1FieldInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint QuadrilateralP1FieldInfo = (~) (Ptr Poppler.Point.Point)
    type AttrTransferTypeConstraint QuadrilateralP1FieldInfo = (~)(Ptr Poppler.Point.Point)
    type AttrTransferType QuadrilateralP1FieldInfo = (Ptr Poppler.Point.Point)
    type AttrGetType QuadrilateralP1FieldInfo = Poppler.Point.Point
    type AttrLabel QuadrilateralP1FieldInfo = "p1"
    type AttrOrigin QuadrilateralP1FieldInfo = Quadrilateral
    attrGet = getQuadrilateralP1
    attrSet = undefined
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer = undefined

quadrilateral_p1 :: AttrLabelProxy "p1"
quadrilateral_p1 = AttrLabelProxy

#endif


-- | Get the value of the “@p2@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' quadrilateral #p2
-- @
getQuadrilateralP2 :: MonadIO m => Quadrilateral -> m Poppler.Point.Point
getQuadrilateralP2 :: Quadrilateral -> m Point
getQuadrilateralP2 Quadrilateral
s = IO Point -> m Point
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Point -> m Point) -> IO Point -> m Point
forall a b. (a -> b) -> a -> b
$ Quadrilateral -> (Ptr Quadrilateral -> IO Point) -> IO Point
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Quadrilateral
s ((Ptr Quadrilateral -> IO Point) -> IO Point)
-> (Ptr Quadrilateral -> IO Point) -> IO Point
forall a b. (a -> b) -> a -> b
$ \Ptr Quadrilateral
ptr -> do
    let val :: Ptr Point
val = Ptr Quadrilateral
ptr Ptr Quadrilateral -> Int -> Ptr Point
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16 :: (Ptr Poppler.Point.Point)
    Point
val' <- ((ManagedPtr Point -> Point) -> Ptr Point -> IO Point
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Point -> Point
Poppler.Point.Point) Ptr Point
val
    Point -> IO Point
forall (m :: * -> *) a. Monad m => a -> m a
return Point
val'

#if defined(ENABLE_OVERLOADING)
data QuadrilateralP2FieldInfo
instance AttrInfo QuadrilateralP2FieldInfo where
    type AttrBaseTypeConstraint QuadrilateralP2FieldInfo = (~) Quadrilateral
    type AttrAllowedOps QuadrilateralP2FieldInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint QuadrilateralP2FieldInfo = (~) (Ptr Poppler.Point.Point)
    type AttrTransferTypeConstraint QuadrilateralP2FieldInfo = (~)(Ptr Poppler.Point.Point)
    type AttrTransferType QuadrilateralP2FieldInfo = (Ptr Poppler.Point.Point)
    type AttrGetType QuadrilateralP2FieldInfo = Poppler.Point.Point
    type AttrLabel QuadrilateralP2FieldInfo = "p2"
    type AttrOrigin QuadrilateralP2FieldInfo = Quadrilateral
    attrGet = getQuadrilateralP2
    attrSet = undefined
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer = undefined

quadrilateral_p2 :: AttrLabelProxy "p2"
quadrilateral_p2 = AttrLabelProxy

#endif


-- | Get the value of the “@p3@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' quadrilateral #p3
-- @
getQuadrilateralP3 :: MonadIO m => Quadrilateral -> m Poppler.Point.Point
getQuadrilateralP3 :: Quadrilateral -> m Point
getQuadrilateralP3 Quadrilateral
s = IO Point -> m Point
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Point -> m Point) -> IO Point -> m Point
forall a b. (a -> b) -> a -> b
$ Quadrilateral -> (Ptr Quadrilateral -> IO Point) -> IO Point
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Quadrilateral
s ((Ptr Quadrilateral -> IO Point) -> IO Point)
-> (Ptr Quadrilateral -> IO Point) -> IO Point
forall a b. (a -> b) -> a -> b
$ \Ptr Quadrilateral
ptr -> do
    let val :: Ptr Point
val = Ptr Quadrilateral
ptr Ptr Quadrilateral -> Int -> Ptr Point
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32 :: (Ptr Poppler.Point.Point)
    Point
val' <- ((ManagedPtr Point -> Point) -> Ptr Point -> IO Point
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Point -> Point
Poppler.Point.Point) Ptr Point
val
    Point -> IO Point
forall (m :: * -> *) a. Monad m => a -> m a
return Point
val'

#if defined(ENABLE_OVERLOADING)
data QuadrilateralP3FieldInfo
instance AttrInfo QuadrilateralP3FieldInfo where
    type AttrBaseTypeConstraint QuadrilateralP3FieldInfo = (~) Quadrilateral
    type AttrAllowedOps QuadrilateralP3FieldInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint QuadrilateralP3FieldInfo = (~) (Ptr Poppler.Point.Point)
    type AttrTransferTypeConstraint QuadrilateralP3FieldInfo = (~)(Ptr Poppler.Point.Point)
    type AttrTransferType QuadrilateralP3FieldInfo = (Ptr Poppler.Point.Point)
    type AttrGetType QuadrilateralP3FieldInfo = Poppler.Point.Point
    type AttrLabel QuadrilateralP3FieldInfo = "p3"
    type AttrOrigin QuadrilateralP3FieldInfo = Quadrilateral
    attrGet = getQuadrilateralP3
    attrSet = undefined
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer = undefined

quadrilateral_p3 :: AttrLabelProxy "p3"
quadrilateral_p3 = AttrLabelProxy

#endif


-- | Get the value of the “@p4@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' quadrilateral #p4
-- @
getQuadrilateralP4 :: MonadIO m => Quadrilateral -> m Poppler.Point.Point
getQuadrilateralP4 :: Quadrilateral -> m Point
getQuadrilateralP4 Quadrilateral
s = IO Point -> m Point
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Point -> m Point) -> IO Point -> m Point
forall a b. (a -> b) -> a -> b
$ Quadrilateral -> (Ptr Quadrilateral -> IO Point) -> IO Point
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Quadrilateral
s ((Ptr Quadrilateral -> IO Point) -> IO Point)
-> (Ptr Quadrilateral -> IO Point) -> IO Point
forall a b. (a -> b) -> a -> b
$ \Ptr Quadrilateral
ptr -> do
    let val :: Ptr Point
val = Ptr Quadrilateral
ptr Ptr Quadrilateral -> Int -> Ptr Point
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
48 :: (Ptr Poppler.Point.Point)
    Point
val' <- ((ManagedPtr Point -> Point) -> Ptr Point -> IO Point
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Point -> Point
Poppler.Point.Point) Ptr Point
val
    Point -> IO Point
forall (m :: * -> *) a. Monad m => a -> m a
return Point
val'

#if defined(ENABLE_OVERLOADING)
data QuadrilateralP4FieldInfo
instance AttrInfo QuadrilateralP4FieldInfo where
    type AttrBaseTypeConstraint QuadrilateralP4FieldInfo = (~) Quadrilateral
    type AttrAllowedOps QuadrilateralP4FieldInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint QuadrilateralP4FieldInfo = (~) (Ptr Poppler.Point.Point)
    type AttrTransferTypeConstraint QuadrilateralP4FieldInfo = (~)(Ptr Poppler.Point.Point)
    type AttrTransferType QuadrilateralP4FieldInfo = (Ptr Poppler.Point.Point)
    type AttrGetType QuadrilateralP4FieldInfo = Poppler.Point.Point
    type AttrLabel QuadrilateralP4FieldInfo = "p4"
    type AttrOrigin QuadrilateralP4FieldInfo = Quadrilateral
    attrGet = getQuadrilateralP4
    attrSet = undefined
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer = undefined

quadrilateral_p4 :: AttrLabelProxy "p4"
quadrilateral_p4 = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Quadrilateral
type instance O.AttributeList Quadrilateral = QuadrilateralAttributeList
type QuadrilateralAttributeList = ('[ '("p1", QuadrilateralP1FieldInfo), '("p2", QuadrilateralP2FieldInfo), '("p3", QuadrilateralP3FieldInfo), '("p4", QuadrilateralP4FieldInfo)] :: [(Symbol, *)])
#endif

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

foreign import ccall "poppler_quadrilateral_new" poppler_quadrilateral_new :: 
    IO (Ptr Quadrilateral)

-- | Creates a new t'GI.Poppler.Structs.Quadrilateral.Quadrilateral'. It must be freed with 'GI.Poppler.Structs.Quadrilateral.quadrilateralFree' after use.
-- 
-- /Since: 0.26/
quadrilateralNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Quadrilateral
    -- ^ __Returns:__ a new t'GI.Poppler.Structs.Quadrilateral.Quadrilateral'.
quadrilateralNew :: m Quadrilateral
quadrilateralNew  = IO Quadrilateral -> m Quadrilateral
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Quadrilateral -> m Quadrilateral)
-> IO Quadrilateral -> m Quadrilateral
forall a b. (a -> b) -> a -> b
$ do
    Ptr Quadrilateral
result <- IO (Ptr Quadrilateral)
poppler_quadrilateral_new
    Text -> Ptr Quadrilateral -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"quadrilateralNew" Ptr Quadrilateral
result
    Quadrilateral
result' <- ((ManagedPtr Quadrilateral -> Quadrilateral)
-> Ptr Quadrilateral -> IO Quadrilateral
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Quadrilateral -> Quadrilateral
Quadrilateral) Ptr Quadrilateral
result
    Quadrilateral -> IO Quadrilateral
forall (m :: * -> *) a. Monad m => a -> m a
return Quadrilateral
result'

#if defined(ENABLE_OVERLOADING)
#endif

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

foreign import ccall "poppler_quadrilateral_copy" poppler_quadrilateral_copy :: 
    Ptr Quadrilateral ->                    -- quad : TInterface (Name {namespace = "Poppler", name = "Quadrilateral"})
    IO (Ptr Quadrilateral)

-- | Creates a copy of /@quad@/. The copy must be freed with 'GI.Poppler.Structs.Quadrilateral.quadrilateralFree' after use.
-- 
-- /Since: 0.26/
quadrilateralCopy ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Quadrilateral
    -- ^ /@quad@/: a t'GI.Poppler.Structs.Quadrilateral.Quadrilateral' to copy
    -> m Quadrilateral
    -- ^ __Returns:__ a new allocated copy of /@quad@/
quadrilateralCopy :: Quadrilateral -> m Quadrilateral
quadrilateralCopy Quadrilateral
quad = IO Quadrilateral -> m Quadrilateral
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Quadrilateral -> m Quadrilateral)
-> IO Quadrilateral -> m Quadrilateral
forall a b. (a -> b) -> a -> b
$ do
    Ptr Quadrilateral
quad' <- Quadrilateral -> IO (Ptr Quadrilateral)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Quadrilateral
quad
    Ptr Quadrilateral
result <- Ptr Quadrilateral -> IO (Ptr Quadrilateral)
poppler_quadrilateral_copy Ptr Quadrilateral
quad'
    Text -> Ptr Quadrilateral -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"quadrilateralCopy" Ptr Quadrilateral
result
    Quadrilateral
result' <- ((ManagedPtr Quadrilateral -> Quadrilateral)
-> Ptr Quadrilateral -> IO Quadrilateral
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Quadrilateral -> Quadrilateral
Quadrilateral) Ptr Quadrilateral
result
    Quadrilateral -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Quadrilateral
quad
    Quadrilateral -> IO Quadrilateral
forall (m :: * -> *) a. Monad m => a -> m a
return Quadrilateral
result'

#if defined(ENABLE_OVERLOADING)
data QuadrilateralCopyMethodInfo
instance (signature ~ (m Quadrilateral), MonadIO m) => O.MethodInfo QuadrilateralCopyMethodInfo Quadrilateral signature where
    overloadedMethod = quadrilateralCopy

#endif

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

foreign import ccall "poppler_quadrilateral_free" poppler_quadrilateral_free :: 
    Ptr Quadrilateral ->                    -- quad : TInterface (Name {namespace = "Poppler", name = "Quadrilateral"})
    IO ()

-- | Frees the memory used by /@quad@/
-- 
-- /Since: 0.26/
quadrilateralFree ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Quadrilateral
    -- ^ /@quad@/: a t'GI.Poppler.Structs.Quadrilateral.Quadrilateral'
    -> m ()
quadrilateralFree :: Quadrilateral -> m ()
quadrilateralFree Quadrilateral
quad = 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 Quadrilateral
quad' <- Quadrilateral -> IO (Ptr Quadrilateral)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Quadrilateral
quad
    Ptr Quadrilateral -> IO ()
poppler_quadrilateral_free Ptr Quadrilateral
quad'
    Quadrilateral -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Quadrilateral
quad
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data QuadrilateralFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo QuadrilateralFreeMethodInfo Quadrilateral signature where
    overloadedMethod = quadrilateralFree

#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveQuadrilateralMethod (t :: Symbol) (o :: *) :: * where
    ResolveQuadrilateralMethod "copy" o = QuadrilateralCopyMethodInfo
    ResolveQuadrilateralMethod "free" o = QuadrilateralFreeMethodInfo
    ResolveQuadrilateralMethod l o = O.MethodResolutionFailed l o

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

#endif