{- |
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.Objects.AnnotMarkup
    ( 

-- * Exported types
    AnnotMarkup(..)                         ,
    IsAnnotMarkup                           ,
    toAnnotMarkup                           ,
    noAnnotMarkup                           ,


 -- * Methods
-- ** getDate #method:getDate#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    AnnotMarkupGetDateMethodInfo            ,
#endif
    annotMarkupGetDate                      ,


-- ** getExternalData #method:getExternalData#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    AnnotMarkupGetExternalDataMethodInfo    ,
#endif
    annotMarkupGetExternalData              ,


-- ** getLabel #method:getLabel#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    AnnotMarkupGetLabelMethodInfo           ,
#endif
    annotMarkupGetLabel                     ,


-- ** getOpacity #method:getOpacity#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    AnnotMarkupGetOpacityMethodInfo         ,
#endif
    annotMarkupGetOpacity                   ,


-- ** getPopupIsOpen #method:getPopupIsOpen#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    AnnotMarkupGetPopupIsOpenMethodInfo     ,
#endif
    annotMarkupGetPopupIsOpen               ,


-- ** getPopupRectangle #method:getPopupRectangle#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    AnnotMarkupGetPopupRectangleMethodInfo  ,
#endif
    annotMarkupGetPopupRectangle            ,


-- ** getReplyTo #method:getReplyTo#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    AnnotMarkupGetReplyToMethodInfo         ,
#endif
    annotMarkupGetReplyTo                   ,


-- ** getSubject #method:getSubject#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    AnnotMarkupGetSubjectMethodInfo         ,
#endif
    annotMarkupGetSubject                   ,


-- ** hasPopup #method:hasPopup#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    AnnotMarkupHasPopupMethodInfo           ,
#endif
    annotMarkupHasPopup                     ,


-- ** setLabel #method:setLabel#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    AnnotMarkupSetLabelMethodInfo           ,
#endif
    annotMarkupSetLabel                     ,


-- ** setOpacity #method:setOpacity#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    AnnotMarkupSetOpacityMethodInfo         ,
#endif
    annotMarkupSetOpacity                   ,


-- ** setPopup #method:setPopup#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    AnnotMarkupSetPopupMethodInfo           ,
#endif
    annotMarkupSetPopup                     ,


-- ** setPopupIsOpen #method:setPopupIsOpen#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    AnnotMarkupSetPopupIsOpenMethodInfo     ,
#endif
    annotMarkupSetPopupIsOpen               ,


-- ** setPopupRectangle #method:setPopupRectangle#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    AnnotMarkupSetPopupRectangleMethodInfo  ,
#endif
    annotMarkupSetPopupRectangle            ,




    ) 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

import qualified GI.GLib.Structs.Date as GLib.Date
import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Poppler.Enums as Poppler.Enums
import {-# SOURCE #-} qualified GI.Poppler.Objects.Annot as Poppler.Annot
import {-# SOURCE #-} qualified GI.Poppler.Structs.Rectangle as Poppler.Rectangle

newtype AnnotMarkup = AnnotMarkup (ManagedPtr AnnotMarkup)
foreign import ccall "poppler_annot_markup_get_type"
    c_poppler_annot_markup_get_type :: IO GType

instance GObject AnnotMarkup where
    gobjectType _ = c_poppler_annot_markup_get_type
    

class GObject o => IsAnnotMarkup o
#if MIN_VERSION_base(4,9,0)
instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError AnnotMarkup a) =>
    IsAnnotMarkup a
#endif
instance IsAnnotMarkup AnnotMarkup
instance Poppler.Annot.IsAnnot AnnotMarkup
instance GObject.Object.IsObject AnnotMarkup

toAnnotMarkup :: (MonadIO m, IsAnnotMarkup o) => o -> m AnnotMarkup
toAnnotMarkup = liftIO . unsafeCastTo AnnotMarkup

noAnnotMarkup :: Maybe AnnotMarkup
noAnnotMarkup = Nothing

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
type family ResolveAnnotMarkupMethod (t :: Symbol) (o :: *) :: * where
    ResolveAnnotMarkupMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveAnnotMarkupMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveAnnotMarkupMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveAnnotMarkupMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveAnnotMarkupMethod "hasPopup" o = AnnotMarkupHasPopupMethodInfo
    ResolveAnnotMarkupMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveAnnotMarkupMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveAnnotMarkupMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveAnnotMarkupMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveAnnotMarkupMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveAnnotMarkupMethod "replaceData" o = GObject.Object.ObjectReplaceDataMethodInfo
    ResolveAnnotMarkupMethod "replaceQdata" o = GObject.Object.ObjectReplaceQdataMethodInfo
    ResolveAnnotMarkupMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveAnnotMarkupMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveAnnotMarkupMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveAnnotMarkupMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveAnnotMarkupMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveAnnotMarkupMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveAnnotMarkupMethod "getAnnotType" o = Poppler.Annot.AnnotGetAnnotTypeMethodInfo
    ResolveAnnotMarkupMethod "getColor" o = Poppler.Annot.AnnotGetColorMethodInfo
    ResolveAnnotMarkupMethod "getContents" o = Poppler.Annot.AnnotGetContentsMethodInfo
    ResolveAnnotMarkupMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveAnnotMarkupMethod "getDate" o = AnnotMarkupGetDateMethodInfo
    ResolveAnnotMarkupMethod "getExternalData" o = AnnotMarkupGetExternalDataMethodInfo
    ResolveAnnotMarkupMethod "getFlags" o = Poppler.Annot.AnnotGetFlagsMethodInfo
    ResolveAnnotMarkupMethod "getLabel" o = AnnotMarkupGetLabelMethodInfo
    ResolveAnnotMarkupMethod "getModified" o = Poppler.Annot.AnnotGetModifiedMethodInfo
    ResolveAnnotMarkupMethod "getName" o = Poppler.Annot.AnnotGetNameMethodInfo
    ResolveAnnotMarkupMethod "getOpacity" o = AnnotMarkupGetOpacityMethodInfo
    ResolveAnnotMarkupMethod "getPageIndex" o = Poppler.Annot.AnnotGetPageIndexMethodInfo
    ResolveAnnotMarkupMethod "getPopupIsOpen" o = AnnotMarkupGetPopupIsOpenMethodInfo
    ResolveAnnotMarkupMethod "getPopupRectangle" o = AnnotMarkupGetPopupRectangleMethodInfo
    ResolveAnnotMarkupMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveAnnotMarkupMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveAnnotMarkupMethod "getRectangle" o = Poppler.Annot.AnnotGetRectangleMethodInfo
    ResolveAnnotMarkupMethod "getReplyTo" o = AnnotMarkupGetReplyToMethodInfo
    ResolveAnnotMarkupMethod "getSubject" o = AnnotMarkupGetSubjectMethodInfo
    ResolveAnnotMarkupMethod "setColor" o = Poppler.Annot.AnnotSetColorMethodInfo
    ResolveAnnotMarkupMethod "setContents" o = Poppler.Annot.AnnotSetContentsMethodInfo
    ResolveAnnotMarkupMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveAnnotMarkupMethod "setFlags" o = Poppler.Annot.AnnotSetFlagsMethodInfo
    ResolveAnnotMarkupMethod "setLabel" o = AnnotMarkupSetLabelMethodInfo
    ResolveAnnotMarkupMethod "setOpacity" o = AnnotMarkupSetOpacityMethodInfo
    ResolveAnnotMarkupMethod "setPopup" o = AnnotMarkupSetPopupMethodInfo
    ResolveAnnotMarkupMethod "setPopupIsOpen" o = AnnotMarkupSetPopupIsOpenMethodInfo
    ResolveAnnotMarkupMethod "setPopupRectangle" o = AnnotMarkupSetPopupRectangleMethodInfo
    ResolveAnnotMarkupMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveAnnotMarkupMethod "setRectangle" o = Poppler.Annot.AnnotSetRectangleMethodInfo
    ResolveAnnotMarkupMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveAnnotMarkupMethod t AnnotMarkup, O.MethodInfo info AnnotMarkup p) => O.IsLabelProxy t (AnnotMarkup -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveAnnotMarkupMethod t AnnotMarkup, O.MethodInfo info AnnotMarkup p) => O.IsLabel t (AnnotMarkup -> 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

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
instance O.HasAttributeList AnnotMarkup
type instance O.AttributeList AnnotMarkup = AnnotMarkupAttributeList
type AnnotMarkupAttributeList = ('[ ] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
#endif

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
type instance O.SignalList AnnotMarkup = AnnotMarkupSignalList
type AnnotMarkupSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

#endif

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

foreign import ccall "poppler_annot_markup_get_date" poppler_annot_markup_get_date :: 
    Ptr AnnotMarkup ->                      -- poppler_annot : TInterface (Name {namespace = "Poppler", name = "AnnotMarkup"})
    IO (Ptr GLib.Date.Date)

{- |
Returns the date and time when the annotation was created
-}
annotMarkupGetDate ::
    (B.CallStack.HasCallStack, MonadIO m, IsAnnotMarkup a) =>
    a
    {- ^ /@popplerAnnot@/: a 'GI.Poppler.Objects.AnnotMarkup.AnnotMarkup' -}
    -> m GLib.Date.Date
    {- ^ __Returns:__ a 'GI.GLib.Structs.Date.Date' representing the date and time
              when the annotation was created, or 'Nothing' -}
annotMarkupGetDate popplerAnnot = liftIO $ do
    popplerAnnot' <- unsafeManagedPtrCastPtr popplerAnnot
    result <- poppler_annot_markup_get_date popplerAnnot'
    checkUnexpectedReturnNULL "annotMarkupGetDate" result
    result' <- (wrapBoxed GLib.Date.Date) result
    touchManagedPtr popplerAnnot
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data AnnotMarkupGetDateMethodInfo
instance (signature ~ (m GLib.Date.Date), MonadIO m, IsAnnotMarkup a) => O.MethodInfo AnnotMarkupGetDateMethodInfo a signature where
    overloadedMethod _ = annotMarkupGetDate

#endif

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

foreign import ccall "poppler_annot_markup_get_external_data" poppler_annot_markup_get_external_data :: 
    Ptr AnnotMarkup ->                      -- poppler_annot : TInterface (Name {namespace = "Poppler", name = "AnnotMarkup"})
    IO CUInt

{- |
Gets the external data type of /@popplerAnnot@/.
-}
annotMarkupGetExternalData ::
    (B.CallStack.HasCallStack, MonadIO m, IsAnnotMarkup a) =>
    a
    {- ^ /@popplerAnnot@/: a 'GI.Poppler.Objects.AnnotMarkup.AnnotMarkup' -}
    -> m Poppler.Enums.AnnotExternalDataType
    {- ^ __Returns:__ 'GI.Poppler.Enums.AnnotExternalDataType' of /@popplerAnnot@/. -}
annotMarkupGetExternalData popplerAnnot = liftIO $ do
    popplerAnnot' <- unsafeManagedPtrCastPtr popplerAnnot
    result <- poppler_annot_markup_get_external_data popplerAnnot'
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr popplerAnnot
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data AnnotMarkupGetExternalDataMethodInfo
instance (signature ~ (m Poppler.Enums.AnnotExternalDataType), MonadIO m, IsAnnotMarkup a) => O.MethodInfo AnnotMarkupGetExternalDataMethodInfo a signature where
    overloadedMethod _ = annotMarkupGetExternalData

#endif

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

foreign import ccall "poppler_annot_markup_get_label" poppler_annot_markup_get_label :: 
    Ptr AnnotMarkup ->                      -- poppler_annot : TInterface (Name {namespace = "Poppler", name = "AnnotMarkup"})
    IO CString

{- |
Retrieves the label text of /@popplerAnnot@/.
-}
annotMarkupGetLabel ::
    (B.CallStack.HasCallStack, MonadIO m, IsAnnotMarkup a) =>
    a
    {- ^ /@popplerAnnot@/: a 'GI.Poppler.Objects.AnnotMarkup.AnnotMarkup' -}
    -> m T.Text
    {- ^ __Returns:__ the label text of /@popplerAnnot@/. -}
annotMarkupGetLabel popplerAnnot = liftIO $ do
    popplerAnnot' <- unsafeManagedPtrCastPtr popplerAnnot
    result <- poppler_annot_markup_get_label popplerAnnot'
    checkUnexpectedReturnNULL "annotMarkupGetLabel" result
    result' <- cstringToText result
    freeMem result
    touchManagedPtr popplerAnnot
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data AnnotMarkupGetLabelMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsAnnotMarkup a) => O.MethodInfo AnnotMarkupGetLabelMethodInfo a signature where
    overloadedMethod _ = annotMarkupGetLabel

#endif

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

foreign import ccall "poppler_annot_markup_get_opacity" poppler_annot_markup_get_opacity :: 
    Ptr AnnotMarkup ->                      -- poppler_annot : TInterface (Name {namespace = "Poppler", name = "AnnotMarkup"})
    IO CDouble

{- |
Retrieves the opacity value of /@popplerAnnot@/.
-}
annotMarkupGetOpacity ::
    (B.CallStack.HasCallStack, MonadIO m, IsAnnotMarkup a) =>
    a
    {- ^ /@popplerAnnot@/: a 'GI.Poppler.Objects.AnnotMarkup.AnnotMarkup' -}
    -> m Double
    {- ^ __Returns:__ the opacity value of /@popplerAnnot@/,
              between 0 (transparent) and 1 (opaque) -}
annotMarkupGetOpacity popplerAnnot = liftIO $ do
    popplerAnnot' <- unsafeManagedPtrCastPtr popplerAnnot
    result <- poppler_annot_markup_get_opacity popplerAnnot'
    let result' = realToFrac result
    touchManagedPtr popplerAnnot
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data AnnotMarkupGetOpacityMethodInfo
instance (signature ~ (m Double), MonadIO m, IsAnnotMarkup a) => O.MethodInfo AnnotMarkupGetOpacityMethodInfo a signature where
    overloadedMethod _ = annotMarkupGetOpacity

#endif

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

foreign import ccall "poppler_annot_markup_get_popup_is_open" poppler_annot_markup_get_popup_is_open :: 
    Ptr AnnotMarkup ->                      -- poppler_annot : TInterface (Name {namespace = "Poppler", name = "AnnotMarkup"})
    IO CInt

{- |
Retrieves the state of the popup window related to /@popplerAnnot@/.
-}
annotMarkupGetPopupIsOpen ::
    (B.CallStack.HasCallStack, MonadIO m, IsAnnotMarkup a) =>
    a
    {- ^ /@popplerAnnot@/: a 'GI.Poppler.Objects.AnnotMarkup.AnnotMarkup' -}
    -> m Bool
    {- ^ __Returns:__ the state of /@popplerAnnot@/. 'True' if it\'s open, 'False' in
              other case. -}
annotMarkupGetPopupIsOpen popplerAnnot = liftIO $ do
    popplerAnnot' <- unsafeManagedPtrCastPtr popplerAnnot
    result <- poppler_annot_markup_get_popup_is_open popplerAnnot'
    let result' = (/= 0) result
    touchManagedPtr popplerAnnot
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data AnnotMarkupGetPopupIsOpenMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsAnnotMarkup a) => O.MethodInfo AnnotMarkupGetPopupIsOpenMethodInfo a signature where
    overloadedMethod _ = annotMarkupGetPopupIsOpen

#endif

-- method AnnotMarkup::get_popup_rectangle
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "poppler_annot", argType = TInterface (Name {namespace = "Poppler", name = "AnnotMarkup"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerAnnotMarkup", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "poppler_rect", argType = TInterface (Name {namespace = "Poppler", name = "Rectangle"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerRectangle to store the popup rectangle", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "poppler_annot_markup_get_popup_rectangle" poppler_annot_markup_get_popup_rectangle :: 
    Ptr AnnotMarkup ->                      -- poppler_annot : TInterface (Name {namespace = "Poppler", name = "AnnotMarkup"})
    Ptr Poppler.Rectangle.Rectangle ->      -- poppler_rect : TInterface (Name {namespace = "Poppler", name = "Rectangle"})
    IO CInt

{- |
Retrieves the rectangle of the popup window related to /@popplerAnnot@/.

@since 0.12
-}
annotMarkupGetPopupRectangle ::
    (B.CallStack.HasCallStack, MonadIO m, IsAnnotMarkup a) =>
    a
    {- ^ /@popplerAnnot@/: a 'GI.Poppler.Objects.AnnotMarkup.AnnotMarkup' -}
    -> m ((Bool, Poppler.Rectangle.Rectangle))
    {- ^ __Returns:__ 'True' if 'GI.Poppler.Structs.Rectangle.Rectangle' was correctly filled, 'False' otherwise -}
annotMarkupGetPopupRectangle popplerAnnot = liftIO $ do
    popplerAnnot' <- unsafeManagedPtrCastPtr popplerAnnot
    popplerRect <- callocBoxedBytes 32 :: IO (Ptr Poppler.Rectangle.Rectangle)
    result <- poppler_annot_markup_get_popup_rectangle popplerAnnot' popplerRect
    let result' = (/= 0) result
    popplerRect' <- (wrapBoxed Poppler.Rectangle.Rectangle) popplerRect
    touchManagedPtr popplerAnnot
    return (result', popplerRect')

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data AnnotMarkupGetPopupRectangleMethodInfo
instance (signature ~ (m ((Bool, Poppler.Rectangle.Rectangle))), MonadIO m, IsAnnotMarkup a) => O.MethodInfo AnnotMarkupGetPopupRectangleMethodInfo a signature where
    overloadedMethod _ = annotMarkupGetPopupRectangle

#endif

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

foreign import ccall "poppler_annot_markup_get_reply_to" poppler_annot_markup_get_reply_to :: 
    Ptr AnnotMarkup ->                      -- poppler_annot : TInterface (Name {namespace = "Poppler", name = "AnnotMarkup"})
    IO CUInt

{- |
Gets the reply type of /@popplerAnnot@/.
-}
annotMarkupGetReplyTo ::
    (B.CallStack.HasCallStack, MonadIO m, IsAnnotMarkup a) =>
    a
    {- ^ /@popplerAnnot@/: a 'GI.Poppler.Objects.AnnotMarkup.AnnotMarkup' -}
    -> m Poppler.Enums.AnnotMarkupReplyType
    {- ^ __Returns:__ 'GI.Poppler.Enums.AnnotMarkupReplyType' of /@popplerAnnot@/. -}
annotMarkupGetReplyTo popplerAnnot = liftIO $ do
    popplerAnnot' <- unsafeManagedPtrCastPtr popplerAnnot
    result <- poppler_annot_markup_get_reply_to popplerAnnot'
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr popplerAnnot
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data AnnotMarkupGetReplyToMethodInfo
instance (signature ~ (m Poppler.Enums.AnnotMarkupReplyType), MonadIO m, IsAnnotMarkup a) => O.MethodInfo AnnotMarkupGetReplyToMethodInfo a signature where
    overloadedMethod _ = annotMarkupGetReplyTo

#endif

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

foreign import ccall "poppler_annot_markup_get_subject" poppler_annot_markup_get_subject :: 
    Ptr AnnotMarkup ->                      -- poppler_annot : TInterface (Name {namespace = "Poppler", name = "AnnotMarkup"})
    IO CString

{- |
Retrives the subject text of /@popplerAnnot@/.
-}
annotMarkupGetSubject ::
    (B.CallStack.HasCallStack, MonadIO m, IsAnnotMarkup a) =>
    a
    {- ^ /@popplerAnnot@/: a 'GI.Poppler.Objects.AnnotMarkup.AnnotMarkup' -}
    -> m T.Text
    {- ^ __Returns:__ the subject text of /@popplerAnnot@/. -}
annotMarkupGetSubject popplerAnnot = liftIO $ do
    popplerAnnot' <- unsafeManagedPtrCastPtr popplerAnnot
    result <- poppler_annot_markup_get_subject popplerAnnot'
    checkUnexpectedReturnNULL "annotMarkupGetSubject" result
    result' <- cstringToText result
    freeMem result
    touchManagedPtr popplerAnnot
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data AnnotMarkupGetSubjectMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsAnnotMarkup a) => O.MethodInfo AnnotMarkupGetSubjectMethodInfo a signature where
    overloadedMethod _ = annotMarkupGetSubject

#endif

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

foreign import ccall "poppler_annot_markup_has_popup" poppler_annot_markup_has_popup :: 
    Ptr AnnotMarkup ->                      -- poppler_annot : TInterface (Name {namespace = "Poppler", name = "AnnotMarkup"})
    IO CInt

{- |
Return 'True' if the markup annotation has a popup window associated

@since 0.12
-}
annotMarkupHasPopup ::
    (B.CallStack.HasCallStack, MonadIO m, IsAnnotMarkup a) =>
    a
    {- ^ /@popplerAnnot@/: a 'GI.Poppler.Objects.AnnotMarkup.AnnotMarkup' -}
    -> m Bool
    {- ^ __Returns:__ 'True', if /@popplerAnnot@/ has popup, 'False' otherwise -}
annotMarkupHasPopup popplerAnnot = liftIO $ do
    popplerAnnot' <- unsafeManagedPtrCastPtr popplerAnnot
    result <- poppler_annot_markup_has_popup popplerAnnot'
    let result' = (/= 0) result
    touchManagedPtr popplerAnnot
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data AnnotMarkupHasPopupMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsAnnotMarkup a) => O.MethodInfo AnnotMarkupHasPopupMethodInfo a signature where
    overloadedMethod _ = annotMarkupHasPopup

#endif

-- method AnnotMarkup::set_label
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "poppler_annot", argType = TInterface (Name {namespace = "Poppler", name = "AnnotMarkup"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerAnnotMarkup", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a text string containing the new label, or %NULL", 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_markup_set_label" poppler_annot_markup_set_label :: 
    Ptr AnnotMarkup ->                      -- poppler_annot : TInterface (Name {namespace = "Poppler", name = "AnnotMarkup"})
    CString ->                              -- label : TBasicType TUTF8
    IO ()

{- |
Sets the label text of /@popplerAnnot@/, replacing the current one

@since 0.16
-}
annotMarkupSetLabel ::
    (B.CallStack.HasCallStack, MonadIO m, IsAnnotMarkup a) =>
    a
    {- ^ /@popplerAnnot@/: a 'GI.Poppler.Objects.AnnotMarkup.AnnotMarkup' -}
    -> Maybe (T.Text)
    {- ^ /@label@/: a text string containing the new label, or 'Nothing' -}
    -> m ()
annotMarkupSetLabel popplerAnnot label = liftIO $ do
    popplerAnnot' <- unsafeManagedPtrCastPtr popplerAnnot
    maybeLabel <- case label of
        Nothing -> return nullPtr
        Just jLabel -> do
            jLabel' <- textToCString jLabel
            return jLabel'
    poppler_annot_markup_set_label popplerAnnot' maybeLabel
    touchManagedPtr popplerAnnot
    freeMem maybeLabel
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data AnnotMarkupSetLabelMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsAnnotMarkup a) => O.MethodInfo AnnotMarkupSetLabelMethodInfo a signature where
    overloadedMethod _ = annotMarkupSetLabel

#endif

-- method AnnotMarkup::set_opacity
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "poppler_annot", argType = TInterface (Name {namespace = "Poppler", name = "AnnotMarkup"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerAnnotMarkup", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "opacity", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a constant opacity value, between 0 (transparent) and 1 (opaque)", 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_markup_set_opacity" poppler_annot_markup_set_opacity :: 
    Ptr AnnotMarkup ->                      -- poppler_annot : TInterface (Name {namespace = "Poppler", name = "AnnotMarkup"})
    CDouble ->                              -- opacity : TBasicType TDouble
    IO ()

{- |
Sets the opacity of /@popplerAnnot@/. This value applies to
all visible elements of /@popplerAnnot@/ in its closed state,
but not to the pop-up window that appears when it\'s openened

@since 0.16
-}
annotMarkupSetOpacity ::
    (B.CallStack.HasCallStack, MonadIO m, IsAnnotMarkup a) =>
    a
    {- ^ /@popplerAnnot@/: a 'GI.Poppler.Objects.AnnotMarkup.AnnotMarkup' -}
    -> Double
    {- ^ /@opacity@/: a constant opacity value, between 0 (transparent) and 1 (opaque) -}
    -> m ()
annotMarkupSetOpacity popplerAnnot opacity = liftIO $ do
    popplerAnnot' <- unsafeManagedPtrCastPtr popplerAnnot
    let opacity' = realToFrac opacity
    poppler_annot_markup_set_opacity popplerAnnot' opacity'
    touchManagedPtr popplerAnnot
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data AnnotMarkupSetOpacityMethodInfo
instance (signature ~ (Double -> m ()), MonadIO m, IsAnnotMarkup a) => O.MethodInfo AnnotMarkupSetOpacityMethodInfo a signature where
    overloadedMethod _ = annotMarkupSetOpacity

#endif

-- method AnnotMarkup::set_popup
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "poppler_annot", argType = TInterface (Name {namespace = "Poppler", name = "AnnotMarkup"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerAnnotMarkup", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "popup_rect", argType = TInterface (Name {namespace = "Poppler", name = "Rectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerRectangle", 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_markup_set_popup" poppler_annot_markup_set_popup :: 
    Ptr AnnotMarkup ->                      -- poppler_annot : TInterface (Name {namespace = "Poppler", name = "AnnotMarkup"})
    Ptr Poppler.Rectangle.Rectangle ->      -- popup_rect : TInterface (Name {namespace = "Poppler", name = "Rectangle"})
    IO ()

{- |
Associates a new popup window for editing contents of /@popplerAnnot@/.
Popup window shall be displayed by viewers at /@popupRect@/ on the page.

@since 0.16
-}
annotMarkupSetPopup ::
    (B.CallStack.HasCallStack, MonadIO m, IsAnnotMarkup a) =>
    a
    {- ^ /@popplerAnnot@/: a 'GI.Poppler.Objects.AnnotMarkup.AnnotMarkup' -}
    -> Poppler.Rectangle.Rectangle
    {- ^ /@popupRect@/: a 'GI.Poppler.Structs.Rectangle.Rectangle' -}
    -> m ()
annotMarkupSetPopup popplerAnnot popupRect = liftIO $ do
    popplerAnnot' <- unsafeManagedPtrCastPtr popplerAnnot
    popupRect' <- unsafeManagedPtrGetPtr popupRect
    poppler_annot_markup_set_popup popplerAnnot' popupRect'
    touchManagedPtr popplerAnnot
    touchManagedPtr popupRect
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data AnnotMarkupSetPopupMethodInfo
instance (signature ~ (Poppler.Rectangle.Rectangle -> m ()), MonadIO m, IsAnnotMarkup a) => O.MethodInfo AnnotMarkupSetPopupMethodInfo a signature where
    overloadedMethod _ = annotMarkupSetPopup

#endif

-- method AnnotMarkup::set_popup_is_open
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "poppler_annot", argType = TInterface (Name {namespace = "Poppler", name = "AnnotMarkup"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerAnnotMarkup", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "is_open", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether popup window should initially be displayed open", 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_markup_set_popup_is_open" poppler_annot_markup_set_popup_is_open :: 
    Ptr AnnotMarkup ->                      -- poppler_annot : TInterface (Name {namespace = "Poppler", name = "AnnotMarkup"})
    CInt ->                                 -- is_open : TBasicType TBoolean
    IO ()

{- |
Sets the state of the popup window related to /@popplerAnnot@/.

@since 0.16
-}
annotMarkupSetPopupIsOpen ::
    (B.CallStack.HasCallStack, MonadIO m, IsAnnotMarkup a) =>
    a
    {- ^ /@popplerAnnot@/: a 'GI.Poppler.Objects.AnnotMarkup.AnnotMarkup' -}
    -> Bool
    {- ^ /@isOpen@/: whether popup window should initially be displayed open -}
    -> m ()
annotMarkupSetPopupIsOpen popplerAnnot isOpen = liftIO $ do
    popplerAnnot' <- unsafeManagedPtrCastPtr popplerAnnot
    let isOpen' = (fromIntegral . fromEnum) isOpen
    poppler_annot_markup_set_popup_is_open popplerAnnot' isOpen'
    touchManagedPtr popplerAnnot
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data AnnotMarkupSetPopupIsOpenMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsAnnotMarkup a) => O.MethodInfo AnnotMarkupSetPopupIsOpenMethodInfo a signature where
    overloadedMethod _ = annotMarkupSetPopupIsOpen

#endif

-- method AnnotMarkup::set_popup_rectangle
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "poppler_annot", argType = TInterface (Name {namespace = "Poppler", name = "AnnotMarkup"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerAnnotMarkup", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "poppler_rect", argType = TInterface (Name {namespace = "Poppler", name = "Rectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerRectangle to set", 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_markup_set_popup_rectangle" poppler_annot_markup_set_popup_rectangle :: 
    Ptr AnnotMarkup ->                      -- poppler_annot : TInterface (Name {namespace = "Poppler", name = "AnnotMarkup"})
    Ptr Poppler.Rectangle.Rectangle ->      -- poppler_rect : TInterface (Name {namespace = "Poppler", name = "Rectangle"})
    IO ()

{- |
Sets the rectangle of the popup window related to /@popplerAnnot@/.
This doesn\'t have any effect if /@popplerAnnot@/ doesn\'t have a
popup associated, use 'GI.Poppler.Objects.AnnotMarkup.annotMarkupSetPopup' to associate
a popup window to a 'GI.Poppler.Objects.AnnotMarkup.AnnotMarkup'.

@since 0.33
-}
annotMarkupSetPopupRectangle ::
    (B.CallStack.HasCallStack, MonadIO m, IsAnnotMarkup a) =>
    a
    {- ^ /@popplerAnnot@/: a 'GI.Poppler.Objects.AnnotMarkup.AnnotMarkup' -}
    -> Poppler.Rectangle.Rectangle
    {- ^ /@popplerRect@/: a 'GI.Poppler.Structs.Rectangle.Rectangle' to set -}
    -> m ()
annotMarkupSetPopupRectangle popplerAnnot popplerRect = liftIO $ do
    popplerAnnot' <- unsafeManagedPtrCastPtr popplerAnnot
    popplerRect' <- unsafeManagedPtrGetPtr popplerRect
    poppler_annot_markup_set_popup_rectangle popplerAnnot' popplerRect'
    touchManagedPtr popplerAnnot
    touchManagedPtr popplerRect
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data AnnotMarkupSetPopupRectangleMethodInfo
instance (signature ~ (Poppler.Rectangle.Rectangle -> m ()), MonadIO m, IsAnnotMarkup a) => O.MethodInfo AnnotMarkupSetPopupRectangleMethodInfo a signature where
    overloadedMethod _ = annotMarkupSetPopupRectangle

#endif