{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- /No description available in the introspection data./

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

module GI.Poppler.Structs.AnnotCalloutLine
    ( 

-- * Exported types
    AnnotCalloutLine(..)                    ,
    newZeroAnnotCalloutLine                 ,


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

#if defined(ENABLE_OVERLOADING)
    ResolveAnnotCalloutLineMethod           ,
#endif

-- ** copy #method:copy#

#if defined(ENABLE_OVERLOADING)
    AnnotCalloutLineCopyMethodInfo          ,
#endif
    annotCalloutLineCopy                    ,


-- ** free #method:free#

#if defined(ENABLE_OVERLOADING)
    AnnotCalloutLineFreeMethodInfo          ,
#endif
    annotCalloutLineFree                    ,


-- ** new #method:new#

    annotCalloutLineNew                     ,




 -- * Properties


-- ** multiline #attr:multiline#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    annotCalloutLine_multiline              ,
#endif
    getAnnotCalloutLineMultiline            ,
    setAnnotCalloutLineMultiline            ,


-- ** x1 #attr:x1#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    annotCalloutLine_x1                     ,
#endif
    getAnnotCalloutLineX1                   ,
    setAnnotCalloutLineX1                   ,


-- ** x2 #attr:x2#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    annotCalloutLine_x2                     ,
#endif
    getAnnotCalloutLineX2                   ,
    setAnnotCalloutLineX2                   ,


-- ** x3 #attr:x3#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    annotCalloutLine_x3                     ,
#endif
    getAnnotCalloutLineX3                   ,
    setAnnotCalloutLineX3                   ,


-- ** y1 #attr:y1#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    annotCalloutLine_y1                     ,
#endif
    getAnnotCalloutLineY1                   ,
    setAnnotCalloutLineY1                   ,


-- ** y2 #attr:y2#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    annotCalloutLine_y2                     ,
#endif
    getAnnotCalloutLineY2                   ,
    setAnnotCalloutLineY2                   ,


-- ** y3 #attr:y3#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    annotCalloutLine_y3                     ,
#endif
    getAnnotCalloutLineY3                   ,
    setAnnotCalloutLineY3                   ,




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


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

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

foreign import ccall "poppler_annot_callout_line_get_type" c_poppler_annot_callout_line_get_type :: 
    IO GType

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

instance B.Types.TypedObject AnnotCalloutLine where
    glibType :: IO GType
glibType = IO GType
c_poppler_annot_callout_line_get_type

instance B.Types.GBoxed AnnotCalloutLine

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

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

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


-- | Get the value of the “@multiline@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' annotCalloutLine #multiline
-- @
getAnnotCalloutLineMultiline :: MonadIO m => AnnotCalloutLine -> m Bool
getAnnotCalloutLineMultiline :: forall (m :: * -> *). MonadIO m => AnnotCalloutLine -> m Bool
getAnnotCalloutLineMultiline AnnotCalloutLine
s = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ AnnotCalloutLine -> (Ptr AnnotCalloutLine -> IO Bool) -> IO Bool
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr AnnotCalloutLine
s ((Ptr AnnotCalloutLine -> IO Bool) -> IO Bool)
-> (Ptr AnnotCalloutLine -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \Ptr AnnotCalloutLine
ptr -> do
    CInt
val <- Ptr CInt -> IO CInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr AnnotCalloutLine
ptr Ptr AnnotCalloutLine -> Int -> Ptr CInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) :: IO CInt
    let val' :: Bool
val' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
val
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
val'

-- | Set the value of the “@multiline@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' annotCalloutLine [ #multiline 'Data.GI.Base.Attributes.:=' value ]
-- @
setAnnotCalloutLineMultiline :: MonadIO m => AnnotCalloutLine -> Bool -> m ()
setAnnotCalloutLineMultiline :: forall (m :: * -> *). MonadIO m => AnnotCalloutLine -> Bool -> m ()
setAnnotCalloutLineMultiline AnnotCalloutLine
s Bool
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
$ AnnotCalloutLine -> (Ptr AnnotCalloutLine -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr AnnotCalloutLine
s ((Ptr AnnotCalloutLine -> IO ()) -> IO ())
-> (Ptr AnnotCalloutLine -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr AnnotCalloutLine
ptr -> do
    let val' :: CInt
val' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
val
    Ptr CInt -> CInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr AnnotCalloutLine
ptr Ptr AnnotCalloutLine -> Int -> Ptr CInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (CInt
val' :: CInt)

#if defined(ENABLE_OVERLOADING)
data AnnotCalloutLineMultilineFieldInfo
instance AttrInfo AnnotCalloutLineMultilineFieldInfo where
    type AttrBaseTypeConstraint AnnotCalloutLineMultilineFieldInfo = (~) AnnotCalloutLine
    type AttrAllowedOps AnnotCalloutLineMultilineFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint AnnotCalloutLineMultilineFieldInfo = (~) Bool
    type AttrTransferTypeConstraint AnnotCalloutLineMultilineFieldInfo = (~)Bool
    type AttrTransferType AnnotCalloutLineMultilineFieldInfo = Bool
    type AttrGetType AnnotCalloutLineMultilineFieldInfo = Bool
    type AttrLabel AnnotCalloutLineMultilineFieldInfo = "multiline"
    type AttrOrigin AnnotCalloutLineMultilineFieldInfo = AnnotCalloutLine
    attrGet = getAnnotCalloutLineMultiline
    attrSet = setAnnotCalloutLineMultiline
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Structs.AnnotCalloutLine.multiline"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.27/docs/GI-Poppler-Structs-AnnotCalloutLine.html#g:attr:multiline"
        })

annotCalloutLine_multiline :: AttrLabelProxy "multiline"
annotCalloutLine_multiline = AttrLabelProxy

#endif


-- | Get the value of the “@x1@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' annotCalloutLine #x1
-- @
getAnnotCalloutLineX1 :: MonadIO m => AnnotCalloutLine -> m Double
getAnnotCalloutLineX1 :: forall (m :: * -> *). MonadIO m => AnnotCalloutLine -> m Double
getAnnotCalloutLineX1 AnnotCalloutLine
s = IO Double -> m Double
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ AnnotCalloutLine
-> (Ptr AnnotCalloutLine -> IO Double) -> IO Double
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr AnnotCalloutLine
s ((Ptr AnnotCalloutLine -> IO Double) -> IO Double)
-> (Ptr AnnotCalloutLine -> IO Double) -> IO Double
forall a b. (a -> b) -> a -> b
$ \Ptr AnnotCalloutLine
ptr -> do
    CDouble
val <- Ptr CDouble -> IO CDouble
forall a. Storable a => Ptr a -> IO a
peek (Ptr AnnotCalloutLine
ptr Ptr AnnotCalloutLine -> Int -> Ptr CDouble
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) :: IO CDouble
    let val' :: Double
val' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
val
    Double -> IO Double
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Double
val'

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

#if defined(ENABLE_OVERLOADING)
data AnnotCalloutLineX1FieldInfo
instance AttrInfo AnnotCalloutLineX1FieldInfo where
    type AttrBaseTypeConstraint AnnotCalloutLineX1FieldInfo = (~) AnnotCalloutLine
    type AttrAllowedOps AnnotCalloutLineX1FieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint AnnotCalloutLineX1FieldInfo = (~) Double
    type AttrTransferTypeConstraint AnnotCalloutLineX1FieldInfo = (~)Double
    type AttrTransferType AnnotCalloutLineX1FieldInfo = Double
    type AttrGetType AnnotCalloutLineX1FieldInfo = Double
    type AttrLabel AnnotCalloutLineX1FieldInfo = "x1"
    type AttrOrigin AnnotCalloutLineX1FieldInfo = AnnotCalloutLine
    attrGet = getAnnotCalloutLineX1
    attrSet = setAnnotCalloutLineX1
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Structs.AnnotCalloutLine.x1"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.27/docs/GI-Poppler-Structs-AnnotCalloutLine.html#g:attr:x1"
        })

annotCalloutLine_x1 :: AttrLabelProxy "x1"
annotCalloutLine_x1 = AttrLabelProxy

#endif


-- | Get the value of the “@y1@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' annotCalloutLine #y1
-- @
getAnnotCalloutLineY1 :: MonadIO m => AnnotCalloutLine -> m Double
getAnnotCalloutLineY1 :: forall (m :: * -> *). MonadIO m => AnnotCalloutLine -> m Double
getAnnotCalloutLineY1 AnnotCalloutLine
s = IO Double -> m Double
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ AnnotCalloutLine
-> (Ptr AnnotCalloutLine -> IO Double) -> IO Double
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr AnnotCalloutLine
s ((Ptr AnnotCalloutLine -> IO Double) -> IO Double)
-> (Ptr AnnotCalloutLine -> IO Double) -> IO Double
forall a b. (a -> b) -> a -> b
$ \Ptr AnnotCalloutLine
ptr -> do
    CDouble
val <- Ptr CDouble -> IO CDouble
forall a. Storable a => Ptr a -> IO a
peek (Ptr AnnotCalloutLine
ptr Ptr AnnotCalloutLine -> Int -> Ptr CDouble
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) :: IO CDouble
    let val' :: Double
val' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
val
    Double -> IO Double
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Double
val'

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

#if defined(ENABLE_OVERLOADING)
data AnnotCalloutLineY1FieldInfo
instance AttrInfo AnnotCalloutLineY1FieldInfo where
    type AttrBaseTypeConstraint AnnotCalloutLineY1FieldInfo = (~) AnnotCalloutLine
    type AttrAllowedOps AnnotCalloutLineY1FieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint AnnotCalloutLineY1FieldInfo = (~) Double
    type AttrTransferTypeConstraint AnnotCalloutLineY1FieldInfo = (~)Double
    type AttrTransferType AnnotCalloutLineY1FieldInfo = Double
    type AttrGetType AnnotCalloutLineY1FieldInfo = Double
    type AttrLabel AnnotCalloutLineY1FieldInfo = "y1"
    type AttrOrigin AnnotCalloutLineY1FieldInfo = AnnotCalloutLine
    attrGet = getAnnotCalloutLineY1
    attrSet = setAnnotCalloutLineY1
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Structs.AnnotCalloutLine.y1"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.27/docs/GI-Poppler-Structs-AnnotCalloutLine.html#g:attr:y1"
        })

annotCalloutLine_y1 :: AttrLabelProxy "y1"
annotCalloutLine_y1 = AttrLabelProxy

#endif


-- | Get the value of the “@x2@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' annotCalloutLine #x2
-- @
getAnnotCalloutLineX2 :: MonadIO m => AnnotCalloutLine -> m Double
getAnnotCalloutLineX2 :: forall (m :: * -> *). MonadIO m => AnnotCalloutLine -> m Double
getAnnotCalloutLineX2 AnnotCalloutLine
s = IO Double -> m Double
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ AnnotCalloutLine
-> (Ptr AnnotCalloutLine -> IO Double) -> IO Double
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr AnnotCalloutLine
s ((Ptr AnnotCalloutLine -> IO Double) -> IO Double)
-> (Ptr AnnotCalloutLine -> IO Double) -> IO Double
forall a b. (a -> b) -> a -> b
$ \Ptr AnnotCalloutLine
ptr -> do
    CDouble
val <- Ptr CDouble -> IO CDouble
forall a. Storable a => Ptr a -> IO a
peek (Ptr AnnotCalloutLine
ptr Ptr AnnotCalloutLine -> Int -> Ptr CDouble
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) :: IO CDouble
    let val' :: Double
val' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
val
    Double -> IO Double
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Double
val'

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

#if defined(ENABLE_OVERLOADING)
data AnnotCalloutLineX2FieldInfo
instance AttrInfo AnnotCalloutLineX2FieldInfo where
    type AttrBaseTypeConstraint AnnotCalloutLineX2FieldInfo = (~) AnnotCalloutLine
    type AttrAllowedOps AnnotCalloutLineX2FieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint AnnotCalloutLineX2FieldInfo = (~) Double
    type AttrTransferTypeConstraint AnnotCalloutLineX2FieldInfo = (~)Double
    type AttrTransferType AnnotCalloutLineX2FieldInfo = Double
    type AttrGetType AnnotCalloutLineX2FieldInfo = Double
    type AttrLabel AnnotCalloutLineX2FieldInfo = "x2"
    type AttrOrigin AnnotCalloutLineX2FieldInfo = AnnotCalloutLine
    attrGet = getAnnotCalloutLineX2
    attrSet = setAnnotCalloutLineX2
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Structs.AnnotCalloutLine.x2"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.27/docs/GI-Poppler-Structs-AnnotCalloutLine.html#g:attr:x2"
        })

annotCalloutLine_x2 :: AttrLabelProxy "x2"
annotCalloutLine_x2 = AttrLabelProxy

#endif


-- | Get the value of the “@y2@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' annotCalloutLine #y2
-- @
getAnnotCalloutLineY2 :: MonadIO m => AnnotCalloutLine -> m Double
getAnnotCalloutLineY2 :: forall (m :: * -> *). MonadIO m => AnnotCalloutLine -> m Double
getAnnotCalloutLineY2 AnnotCalloutLine
s = IO Double -> m Double
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ AnnotCalloutLine
-> (Ptr AnnotCalloutLine -> IO Double) -> IO Double
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr AnnotCalloutLine
s ((Ptr AnnotCalloutLine -> IO Double) -> IO Double)
-> (Ptr AnnotCalloutLine -> IO Double) -> IO Double
forall a b. (a -> b) -> a -> b
$ \Ptr AnnotCalloutLine
ptr -> do
    CDouble
val <- Ptr CDouble -> IO CDouble
forall a. Storable a => Ptr a -> IO a
peek (Ptr AnnotCalloutLine
ptr Ptr AnnotCalloutLine -> Int -> Ptr CDouble
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) :: IO CDouble
    let val' :: Double
val' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
val
    Double -> IO Double
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Double
val'

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

#if defined(ENABLE_OVERLOADING)
data AnnotCalloutLineY2FieldInfo
instance AttrInfo AnnotCalloutLineY2FieldInfo where
    type AttrBaseTypeConstraint AnnotCalloutLineY2FieldInfo = (~) AnnotCalloutLine
    type AttrAllowedOps AnnotCalloutLineY2FieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint AnnotCalloutLineY2FieldInfo = (~) Double
    type AttrTransferTypeConstraint AnnotCalloutLineY2FieldInfo = (~)Double
    type AttrTransferType AnnotCalloutLineY2FieldInfo = Double
    type AttrGetType AnnotCalloutLineY2FieldInfo = Double
    type AttrLabel AnnotCalloutLineY2FieldInfo = "y2"
    type AttrOrigin AnnotCalloutLineY2FieldInfo = AnnotCalloutLine
    attrGet = getAnnotCalloutLineY2
    attrSet = setAnnotCalloutLineY2
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Structs.AnnotCalloutLine.y2"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.27/docs/GI-Poppler-Structs-AnnotCalloutLine.html#g:attr:y2"
        })

annotCalloutLine_y2 :: AttrLabelProxy "y2"
annotCalloutLine_y2 = AttrLabelProxy

#endif


-- | Get the value of the “@x3@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' annotCalloutLine #x3
-- @
getAnnotCalloutLineX3 :: MonadIO m => AnnotCalloutLine -> m Double
getAnnotCalloutLineX3 :: forall (m :: * -> *). MonadIO m => AnnotCalloutLine -> m Double
getAnnotCalloutLineX3 AnnotCalloutLine
s = IO Double -> m Double
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ AnnotCalloutLine
-> (Ptr AnnotCalloutLine -> IO Double) -> IO Double
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr AnnotCalloutLine
s ((Ptr AnnotCalloutLine -> IO Double) -> IO Double)
-> (Ptr AnnotCalloutLine -> IO Double) -> IO Double
forall a b. (a -> b) -> a -> b
$ \Ptr AnnotCalloutLine
ptr -> do
    CDouble
val <- Ptr CDouble -> IO CDouble
forall a. Storable a => Ptr a -> IO a
peek (Ptr AnnotCalloutLine
ptr Ptr AnnotCalloutLine -> Int -> Ptr CDouble
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
40) :: IO CDouble
    let val' :: Double
val' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
val
    Double -> IO Double
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Double
val'

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

#if defined(ENABLE_OVERLOADING)
data AnnotCalloutLineX3FieldInfo
instance AttrInfo AnnotCalloutLineX3FieldInfo where
    type AttrBaseTypeConstraint AnnotCalloutLineX3FieldInfo = (~) AnnotCalloutLine
    type AttrAllowedOps AnnotCalloutLineX3FieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint AnnotCalloutLineX3FieldInfo = (~) Double
    type AttrTransferTypeConstraint AnnotCalloutLineX3FieldInfo = (~)Double
    type AttrTransferType AnnotCalloutLineX3FieldInfo = Double
    type AttrGetType AnnotCalloutLineX3FieldInfo = Double
    type AttrLabel AnnotCalloutLineX3FieldInfo = "x3"
    type AttrOrigin AnnotCalloutLineX3FieldInfo = AnnotCalloutLine
    attrGet = getAnnotCalloutLineX3
    attrSet = setAnnotCalloutLineX3
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Structs.AnnotCalloutLine.x3"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.27/docs/GI-Poppler-Structs-AnnotCalloutLine.html#g:attr:x3"
        })

annotCalloutLine_x3 :: AttrLabelProxy "x3"
annotCalloutLine_x3 = AttrLabelProxy

#endif


-- | Get the value of the “@y3@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' annotCalloutLine #y3
-- @
getAnnotCalloutLineY3 :: MonadIO m => AnnotCalloutLine -> m Double
getAnnotCalloutLineY3 :: forall (m :: * -> *). MonadIO m => AnnotCalloutLine -> m Double
getAnnotCalloutLineY3 AnnotCalloutLine
s = IO Double -> m Double
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ AnnotCalloutLine
-> (Ptr AnnotCalloutLine -> IO Double) -> IO Double
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr AnnotCalloutLine
s ((Ptr AnnotCalloutLine -> IO Double) -> IO Double)
-> (Ptr AnnotCalloutLine -> IO Double) -> IO Double
forall a b. (a -> b) -> a -> b
$ \Ptr AnnotCalloutLine
ptr -> do
    CDouble
val <- Ptr CDouble -> IO CDouble
forall a. Storable a => Ptr a -> IO a
peek (Ptr AnnotCalloutLine
ptr Ptr AnnotCalloutLine -> Int -> Ptr CDouble
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
48) :: IO CDouble
    let val' :: Double
val' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
val
    Double -> IO Double
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Double
val'

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

#if defined(ENABLE_OVERLOADING)
data AnnotCalloutLineY3FieldInfo
instance AttrInfo AnnotCalloutLineY3FieldInfo where
    type AttrBaseTypeConstraint AnnotCalloutLineY3FieldInfo = (~) AnnotCalloutLine
    type AttrAllowedOps AnnotCalloutLineY3FieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint AnnotCalloutLineY3FieldInfo = (~) Double
    type AttrTransferTypeConstraint AnnotCalloutLineY3FieldInfo = (~)Double
    type AttrTransferType AnnotCalloutLineY3FieldInfo = Double
    type AttrGetType AnnotCalloutLineY3FieldInfo = Double
    type AttrLabel AnnotCalloutLineY3FieldInfo = "y3"
    type AttrOrigin AnnotCalloutLineY3FieldInfo = AnnotCalloutLine
    attrGet = getAnnotCalloutLineY3
    attrSet = setAnnotCalloutLineY3
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Poppler.Structs.AnnotCalloutLine.y3"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-poppler-0.18.27/docs/GI-Poppler-Structs-AnnotCalloutLine.html#g:attr:y3"
        })

annotCalloutLine_y3 :: AttrLabelProxy "y3"
annotCalloutLine_y3 = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList AnnotCalloutLine
type instance O.AttributeList AnnotCalloutLine = AnnotCalloutLineAttributeList
type AnnotCalloutLineAttributeList = ('[ '("multiline", AnnotCalloutLineMultilineFieldInfo), '("x1", AnnotCalloutLineX1FieldInfo), '("y1", AnnotCalloutLineY1FieldInfo), '("x2", AnnotCalloutLineX2FieldInfo), '("y2", AnnotCalloutLineY2FieldInfo), '("x3", AnnotCalloutLineX3FieldInfo), '("y3", AnnotCalloutLineY3FieldInfo)] :: [(Symbol, *)])
#endif

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

foreign import ccall "poppler_annot_callout_line_new" poppler_annot_callout_line_new :: 
    IO (Ptr AnnotCalloutLine)

-- | Creates a new empty t'GI.Poppler.Structs.AnnotCalloutLine.AnnotCalloutLine'.
annotCalloutLineNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m AnnotCalloutLine
    -- ^ __Returns:__ a new allocated t'GI.Poppler.Structs.AnnotCalloutLine.AnnotCalloutLine', 'P.Nothing' in other case.
    --               It must be freed when done.
annotCalloutLineNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
m AnnotCalloutLine
annotCalloutLineNew  = IO AnnotCalloutLine -> m AnnotCalloutLine
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO AnnotCalloutLine -> m AnnotCalloutLine)
-> IO AnnotCalloutLine -> m AnnotCalloutLine
forall a b. (a -> b) -> a -> b
$ do
    Ptr AnnotCalloutLine
result <- IO (Ptr AnnotCalloutLine)
poppler_annot_callout_line_new
    Text -> Ptr AnnotCalloutLine -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"annotCalloutLineNew" Ptr AnnotCalloutLine
result
    AnnotCalloutLine
result' <- ((ManagedPtr AnnotCalloutLine -> AnnotCalloutLine)
-> Ptr AnnotCalloutLine -> IO AnnotCalloutLine
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr AnnotCalloutLine -> AnnotCalloutLine
AnnotCalloutLine) Ptr AnnotCalloutLine
result
    AnnotCalloutLine -> IO AnnotCalloutLine
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return AnnotCalloutLine
result'

#if defined(ENABLE_OVERLOADING)
#endif

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

foreign import ccall "poppler_annot_callout_line_copy" poppler_annot_callout_line_copy :: 
    Ptr AnnotCalloutLine ->                 -- callout : TInterface (Name {namespace = "Poppler", name = "AnnotCalloutLine"})
    IO (Ptr AnnotCalloutLine)

-- | It does copy /@callout@/ to a new t'GI.Poppler.Structs.AnnotCalloutLine.AnnotCalloutLine'.
annotCalloutLineCopy ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    AnnotCalloutLine
    -- ^ /@callout@/: the t'GI.Poppler.Structs.AnnotCalloutLine.AnnotCalloutLine' to be copied.
    -> m AnnotCalloutLine
    -- ^ __Returns:__ a new allocated t'GI.Poppler.Structs.AnnotCalloutLine.AnnotCalloutLine' as exact copy of
    --               /@callout@/, 'P.Nothing' in other case. It must be freed when done.
annotCalloutLineCopy :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
AnnotCalloutLine -> m AnnotCalloutLine
annotCalloutLineCopy AnnotCalloutLine
callout = IO AnnotCalloutLine -> m AnnotCalloutLine
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO AnnotCalloutLine -> m AnnotCalloutLine)
-> IO AnnotCalloutLine -> m AnnotCalloutLine
forall a b. (a -> b) -> a -> b
$ do
    Ptr AnnotCalloutLine
callout' <- AnnotCalloutLine -> IO (Ptr AnnotCalloutLine)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr AnnotCalloutLine
callout
    Ptr AnnotCalloutLine
result <- Ptr AnnotCalloutLine -> IO (Ptr AnnotCalloutLine)
poppler_annot_callout_line_copy Ptr AnnotCalloutLine
callout'
    Text -> Ptr AnnotCalloutLine -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"annotCalloutLineCopy" Ptr AnnotCalloutLine
result
    AnnotCalloutLine
result' <- ((ManagedPtr AnnotCalloutLine -> AnnotCalloutLine)
-> Ptr AnnotCalloutLine -> IO AnnotCalloutLine
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr AnnotCalloutLine -> AnnotCalloutLine
AnnotCalloutLine) Ptr AnnotCalloutLine
result
    AnnotCalloutLine -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr AnnotCalloutLine
callout
    AnnotCalloutLine -> IO AnnotCalloutLine
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return AnnotCalloutLine
result'

#if defined(ENABLE_OVERLOADING)
data AnnotCalloutLineCopyMethodInfo
instance (signature ~ (m AnnotCalloutLine), MonadIO m) => O.OverloadedMethod AnnotCalloutLineCopyMethodInfo AnnotCalloutLine signature where
    overloadedMethod = annotCalloutLineCopy

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


#endif

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

foreign import ccall "poppler_annot_callout_line_free" poppler_annot_callout_line_free :: 
    Ptr AnnotCalloutLine ->                 -- callout : TInterface (Name {namespace = "Poppler", name = "AnnotCalloutLine"})
    IO ()

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

#if defined(ENABLE_OVERLOADING)
data AnnotCalloutLineFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod AnnotCalloutLineFreeMethodInfo AnnotCalloutLine signature where
    overloadedMethod = annotCalloutLineFree

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


#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveAnnotCalloutLineMethod (t :: Symbol) (o :: *) :: * where
    ResolveAnnotCalloutLineMethod "copy" o = AnnotCalloutLineCopyMethodInfo
    ResolveAnnotCalloutLineMethod "free" o = AnnotCalloutLineFreeMethodInfo
    ResolveAnnotCalloutLineMethod l o = O.MethodResolutionFailed l o

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

#endif

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

#endif