{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
-}

module GI.Poppler.Structs.AnnotCalloutLine
    ( 

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


 -- * Methods
-- ** copy #method:copy#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    AnnotCalloutLineCopyMethodInfo          ,
#endif
    annotCalloutLineCopy                    ,


-- ** free #method:free#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    AnnotCalloutLineFreeMethodInfo          ,
#endif
    annotCalloutLineFree                    ,


-- ** new #method:new#
    annotCalloutLineNew                     ,




 -- * Properties
-- ** multiline #attr:multiline#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    annotCalloutLine_multiline              ,
#endif
    getAnnotCalloutLineMultiline            ,
    setAnnotCalloutLineMultiline            ,


-- ** x1 #attr:x1#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    annotCalloutLine_x1                     ,
#endif
    getAnnotCalloutLineX1                   ,
    setAnnotCalloutLineX1                   ,


-- ** x2 #attr:x2#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    annotCalloutLine_x2                     ,
#endif
    getAnnotCalloutLineX2                   ,
    setAnnotCalloutLineX2                   ,


-- ** x3 #attr:x3#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    annotCalloutLine_x3                     ,
#endif
    getAnnotCalloutLineX3                   ,
    setAnnotCalloutLineX3                   ,


-- ** y1 #attr:y1#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    annotCalloutLine_y1                     ,
#endif
    getAnnotCalloutLineY1                   ,
    setAnnotCalloutLineY1                   ,


-- ** y2 #attr:y2#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    annotCalloutLine_y2                     ,
#endif
    getAnnotCalloutLineY2                   ,
    setAnnotCalloutLineY2                   ,


-- ** y3 #attr:y3#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    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.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
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


newtype AnnotCalloutLine = AnnotCalloutLine (ManagedPtr AnnotCalloutLine)
foreign import ccall "poppler_annot_callout_line_get_type" c_poppler_annot_callout_line_get_type :: 
    IO GType

instance BoxedObject AnnotCalloutLine where
    boxedType _ = c_poppler_annot_callout_line_get_type

-- | Construct a `AnnotCalloutLine` struct initialized to zero.
newZeroAnnotCalloutLine :: MonadIO m => m AnnotCalloutLine
newZeroAnnotCalloutLine = liftIO $ callocBoxedBytes 56 >>= wrapBoxed AnnotCalloutLine

instance tag ~ 'AttrSet => Constructible AnnotCalloutLine tag where
    new _ attrs = do
        o <- newZeroAnnotCalloutLine
        GI.Attributes.set o attrs
        return o


noAnnotCalloutLine :: Maybe AnnotCalloutLine
noAnnotCalloutLine = Nothing

getAnnotCalloutLineMultiline :: MonadIO m => AnnotCalloutLine -> m Bool
getAnnotCalloutLineMultiline s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO CInt
    let val' = (/= 0) val
    return val'

setAnnotCalloutLineMultiline :: MonadIO m => AnnotCalloutLine -> Bool -> m ()
setAnnotCalloutLineMultiline s val = liftIO $ withManagedPtr s $ \ptr -> do
    let val' = (fromIntegral . fromEnum) val
    poke (ptr `plusPtr` 0) (val' :: CInt)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data AnnotCalloutLineMultilineFieldInfo
instance AttrInfo AnnotCalloutLineMultilineFieldInfo where
    type AttrAllowedOps AnnotCalloutLineMultilineFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint AnnotCalloutLineMultilineFieldInfo = (~) Bool
    type AttrBaseTypeConstraint AnnotCalloutLineMultilineFieldInfo = (~) AnnotCalloutLine
    type AttrGetType AnnotCalloutLineMultilineFieldInfo = Bool
    type AttrLabel AnnotCalloutLineMultilineFieldInfo = "multiline"
    type AttrOrigin AnnotCalloutLineMultilineFieldInfo = AnnotCalloutLine
    attrGet _ = getAnnotCalloutLineMultiline
    attrSet _ = setAnnotCalloutLineMultiline
    attrConstruct = undefined
    attrClear _ = undefined

annotCalloutLine_multiline :: AttrLabelProxy "multiline"
annotCalloutLine_multiline = AttrLabelProxy

#endif


getAnnotCalloutLineX1 :: MonadIO m => AnnotCalloutLine -> m Double
getAnnotCalloutLineX1 s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 8) :: IO CDouble
    let val' = realToFrac val
    return val'

setAnnotCalloutLineX1 :: MonadIO m => AnnotCalloutLine -> Double -> m ()
setAnnotCalloutLineX1 s val = liftIO $ withManagedPtr s $ \ptr -> do
    let val' = realToFrac val
    poke (ptr `plusPtr` 8) (val' :: CDouble)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data AnnotCalloutLineX1FieldInfo
instance AttrInfo AnnotCalloutLineX1FieldInfo where
    type AttrAllowedOps AnnotCalloutLineX1FieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint AnnotCalloutLineX1FieldInfo = (~) Double
    type AttrBaseTypeConstraint AnnotCalloutLineX1FieldInfo = (~) AnnotCalloutLine
    type AttrGetType AnnotCalloutLineX1FieldInfo = Double
    type AttrLabel AnnotCalloutLineX1FieldInfo = "x1"
    type AttrOrigin AnnotCalloutLineX1FieldInfo = AnnotCalloutLine
    attrGet _ = getAnnotCalloutLineX1
    attrSet _ = setAnnotCalloutLineX1
    attrConstruct = undefined
    attrClear _ = undefined

annotCalloutLine_x1 :: AttrLabelProxy "x1"
annotCalloutLine_x1 = AttrLabelProxy

#endif


getAnnotCalloutLineY1 :: MonadIO m => AnnotCalloutLine -> m Double
getAnnotCalloutLineY1 s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 16) :: IO CDouble
    let val' = realToFrac val
    return val'

setAnnotCalloutLineY1 :: MonadIO m => AnnotCalloutLine -> Double -> m ()
setAnnotCalloutLineY1 s val = liftIO $ withManagedPtr s $ \ptr -> do
    let val' = realToFrac val
    poke (ptr `plusPtr` 16) (val' :: CDouble)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data AnnotCalloutLineY1FieldInfo
instance AttrInfo AnnotCalloutLineY1FieldInfo where
    type AttrAllowedOps AnnotCalloutLineY1FieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint AnnotCalloutLineY1FieldInfo = (~) Double
    type AttrBaseTypeConstraint AnnotCalloutLineY1FieldInfo = (~) AnnotCalloutLine
    type AttrGetType AnnotCalloutLineY1FieldInfo = Double
    type AttrLabel AnnotCalloutLineY1FieldInfo = "y1"
    type AttrOrigin AnnotCalloutLineY1FieldInfo = AnnotCalloutLine
    attrGet _ = getAnnotCalloutLineY1
    attrSet _ = setAnnotCalloutLineY1
    attrConstruct = undefined
    attrClear _ = undefined

annotCalloutLine_y1 :: AttrLabelProxy "y1"
annotCalloutLine_y1 = AttrLabelProxy

#endif


getAnnotCalloutLineX2 :: MonadIO m => AnnotCalloutLine -> m Double
getAnnotCalloutLineX2 s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 24) :: IO CDouble
    let val' = realToFrac val
    return val'

setAnnotCalloutLineX2 :: MonadIO m => AnnotCalloutLine -> Double -> m ()
setAnnotCalloutLineX2 s val = liftIO $ withManagedPtr s $ \ptr -> do
    let val' = realToFrac val
    poke (ptr `plusPtr` 24) (val' :: CDouble)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data AnnotCalloutLineX2FieldInfo
instance AttrInfo AnnotCalloutLineX2FieldInfo where
    type AttrAllowedOps AnnotCalloutLineX2FieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint AnnotCalloutLineX2FieldInfo = (~) Double
    type AttrBaseTypeConstraint AnnotCalloutLineX2FieldInfo = (~) AnnotCalloutLine
    type AttrGetType AnnotCalloutLineX2FieldInfo = Double
    type AttrLabel AnnotCalloutLineX2FieldInfo = "x2"
    type AttrOrigin AnnotCalloutLineX2FieldInfo = AnnotCalloutLine
    attrGet _ = getAnnotCalloutLineX2
    attrSet _ = setAnnotCalloutLineX2
    attrConstruct = undefined
    attrClear _ = undefined

annotCalloutLine_x2 :: AttrLabelProxy "x2"
annotCalloutLine_x2 = AttrLabelProxy

#endif


getAnnotCalloutLineY2 :: MonadIO m => AnnotCalloutLine -> m Double
getAnnotCalloutLineY2 s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 32) :: IO CDouble
    let val' = realToFrac val
    return val'

setAnnotCalloutLineY2 :: MonadIO m => AnnotCalloutLine -> Double -> m ()
setAnnotCalloutLineY2 s val = liftIO $ withManagedPtr s $ \ptr -> do
    let val' = realToFrac val
    poke (ptr `plusPtr` 32) (val' :: CDouble)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data AnnotCalloutLineY2FieldInfo
instance AttrInfo AnnotCalloutLineY2FieldInfo where
    type AttrAllowedOps AnnotCalloutLineY2FieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint AnnotCalloutLineY2FieldInfo = (~) Double
    type AttrBaseTypeConstraint AnnotCalloutLineY2FieldInfo = (~) AnnotCalloutLine
    type AttrGetType AnnotCalloutLineY2FieldInfo = Double
    type AttrLabel AnnotCalloutLineY2FieldInfo = "y2"
    type AttrOrigin AnnotCalloutLineY2FieldInfo = AnnotCalloutLine
    attrGet _ = getAnnotCalloutLineY2
    attrSet _ = setAnnotCalloutLineY2
    attrConstruct = undefined
    attrClear _ = undefined

annotCalloutLine_y2 :: AttrLabelProxy "y2"
annotCalloutLine_y2 = AttrLabelProxy

#endif


getAnnotCalloutLineX3 :: MonadIO m => AnnotCalloutLine -> m Double
getAnnotCalloutLineX3 s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 40) :: IO CDouble
    let val' = realToFrac val
    return val'

setAnnotCalloutLineX3 :: MonadIO m => AnnotCalloutLine -> Double -> m ()
setAnnotCalloutLineX3 s val = liftIO $ withManagedPtr s $ \ptr -> do
    let val' = realToFrac val
    poke (ptr `plusPtr` 40) (val' :: CDouble)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data AnnotCalloutLineX3FieldInfo
instance AttrInfo AnnotCalloutLineX3FieldInfo where
    type AttrAllowedOps AnnotCalloutLineX3FieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint AnnotCalloutLineX3FieldInfo = (~) Double
    type AttrBaseTypeConstraint AnnotCalloutLineX3FieldInfo = (~) AnnotCalloutLine
    type AttrGetType AnnotCalloutLineX3FieldInfo = Double
    type AttrLabel AnnotCalloutLineX3FieldInfo = "x3"
    type AttrOrigin AnnotCalloutLineX3FieldInfo = AnnotCalloutLine
    attrGet _ = getAnnotCalloutLineX3
    attrSet _ = setAnnotCalloutLineX3
    attrConstruct = undefined
    attrClear _ = undefined

annotCalloutLine_x3 :: AttrLabelProxy "x3"
annotCalloutLine_x3 = AttrLabelProxy

#endif


getAnnotCalloutLineY3 :: MonadIO m => AnnotCalloutLine -> m Double
getAnnotCalloutLineY3 s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 48) :: IO CDouble
    let val' = realToFrac val
    return val'

setAnnotCalloutLineY3 :: MonadIO m => AnnotCalloutLine -> Double -> m ()
setAnnotCalloutLineY3 s val = liftIO $ withManagedPtr s $ \ptr -> do
    let val' = realToFrac val
    poke (ptr `plusPtr` 48) (val' :: CDouble)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data AnnotCalloutLineY3FieldInfo
instance AttrInfo AnnotCalloutLineY3FieldInfo where
    type AttrAllowedOps AnnotCalloutLineY3FieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint AnnotCalloutLineY3FieldInfo = (~) Double
    type AttrBaseTypeConstraint AnnotCalloutLineY3FieldInfo = (~) AnnotCalloutLine
    type AttrGetType AnnotCalloutLineY3FieldInfo = Double
    type AttrLabel AnnotCalloutLineY3FieldInfo = "y3"
    type AttrOrigin AnnotCalloutLineY3FieldInfo = AnnotCalloutLine
    attrGet _ = getAnnotCalloutLineY3
    attrSet _ = setAnnotCalloutLineY3
    attrConstruct = undefined
    attrClear _ = undefined

annotCalloutLine_y3 :: AttrLabelProxy "y3"
annotCalloutLine_y3 = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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 'GI.Poppler.Structs.AnnotCalloutLine.AnnotCalloutLine'.
-}
annotCalloutLineNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m AnnotCalloutLine
    {- ^ __Returns:__ a new allocated 'GI.Poppler.Structs.AnnotCalloutLine.AnnotCalloutLine', 'Nothing' in other case.
              It must be freed when done. -}
annotCalloutLineNew  = liftIO $ do
    result <- poppler_annot_callout_line_new
    checkUnexpectedReturnNULL "annotCalloutLineNew" result
    result' <- (wrapBoxed AnnotCalloutLine) result
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
#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 'GI.Poppler.Structs.AnnotCalloutLine.AnnotCalloutLine'.
-}
annotCalloutLineCopy ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    AnnotCalloutLine
    {- ^ /@callout@/: the 'GI.Poppler.Structs.AnnotCalloutLine.AnnotCalloutLine' to be copied. -}
    -> m AnnotCalloutLine
    {- ^ __Returns:__ a new allocated 'GI.Poppler.Structs.AnnotCalloutLine.AnnotCalloutLine' as exact copy of
              /@callout@/, 'Nothing' in other case. It must be freed when done. -}
annotCalloutLineCopy callout = liftIO $ do
    callout' <- unsafeManagedPtrGetPtr callout
    result <- poppler_annot_callout_line_copy callout'
    checkUnexpectedReturnNULL "annotCalloutLineCopy" result
    result' <- (wrapBoxed AnnotCalloutLine) result
    touchManagedPtr callout
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data AnnotCalloutLineCopyMethodInfo
instance (signature ~ (m AnnotCalloutLine), MonadIO m) => O.MethodInfo AnnotCalloutLineCopyMethodInfo AnnotCalloutLine signature where
    overloadedMethod _ = 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 'GI.Poppler.Structs.AnnotCalloutLine.AnnotCalloutLine'.
-}
annotCalloutLineFree ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    AnnotCalloutLine
    {- ^ /@callout@/: a 'GI.Poppler.Structs.AnnotCalloutLine.AnnotCalloutLine' -}
    -> m ()
annotCalloutLineFree callout = liftIO $ do
    callout' <- unsafeManagedPtrGetPtr callout
    poppler_annot_callout_line_free callout'
    touchManagedPtr callout
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data AnnotCalloutLineFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo AnnotCalloutLineFreeMethodInfo AnnotCalloutLine signature where
    overloadedMethod _ = annotCalloutLineFree

#endif

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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.MethodInfo info AnnotCalloutLine p) => O.IsLabelProxy t (AnnotCalloutLine -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveAnnotCalloutLineMethod t AnnotCalloutLine, O.MethodInfo info AnnotCalloutLine p) => O.IsLabel t (AnnotCalloutLine -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#else
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif
#endif

#endif