packages feed

gi-poppler (empty) → 0.0.30.12

raw patch · 113 files changed

+16902/−0 lines, 113 filesdep +basedep +bytestringdep +containerssetup-changed

Dependencies added: base, bytestring, containers, gi-cairo, gi-gio, gi-glib, gi-gobject, haskell-gi-base, text, transformers

Files

+ GI/Poppler.hs view
@@ -0,0 +1,40 @@++{- |+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+    (     module GI.Poppler.Callbacks             ,+    module GI.Poppler.Constants             ,+    module GI.Poppler.Enums                 ,+    module GI.Poppler.Flags                 ,+    module GI.Poppler.Functions             ,+    module GI.Poppler.Objects               ,+    module GI.Poppler.Structs               ,+    module GI.Poppler.Unions                ,+++    ) where++import GI.Poppler.Callbacks+import GI.Poppler.Constants+import GI.Poppler.Enums+import GI.Poppler.Flags+import GI.Poppler.Functions+import GI.Poppler.Objects+import GI.Poppler.Structs+import GI.Poppler.Unions++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Poppler.Types+import GI.Poppler.Callbacks++
+ GI/Poppler/Callbacks.hs view
@@ -0,0 +1,114 @@++{- |+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.Callbacks+    ( ++ -- * Signals+-- ** AttachmentSaveFunc+    AttachmentSaveFunc                      ,+    AttachmentSaveFuncC                     ,+    attachmentSaveFuncClosure               ,+    attachmentSaveFuncWrapper               ,+    mkAttachmentSaveFunc                    ,+    noAttachmentSaveFunc                    ,+++-- ** MediaSaveFunc+    MediaSaveFunc                           ,+    MediaSaveFuncC                          ,+    mediaSaveFuncClosure                    ,+    mediaSaveFuncWrapper                    ,+    mkMediaSaveFunc                         ,+    noMediaSaveFunc                         ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Poppler.Types+++-- callback MediaSaveFunc+mediaSaveFuncClosure :: MediaSaveFunc -> IO Closure+mediaSaveFuncClosure cb = newCClosure =<< mkMediaSaveFunc wrapped+    where wrapped = mediaSaveFuncWrapper Nothing cb++type MediaSaveFuncC =+    Ptr Word8 ->+    Word64 ->+    Ptr () ->+    IO CInt++foreign import ccall "wrapper"+    mkMediaSaveFunc :: MediaSaveFuncC -> IO (FunPtr MediaSaveFuncC)++type MediaSaveFunc =+    ByteString ->+    IO Bool++noMediaSaveFunc :: Maybe MediaSaveFunc+noMediaSaveFunc = Nothing++mediaSaveFuncWrapper ::+    Maybe (Ptr (FunPtr (MediaSaveFuncC))) ->+    MediaSaveFunc ->+    Ptr Word8 ->+    Word64 ->+    Ptr () ->+    IO CInt+mediaSaveFuncWrapper funptrptr _cb buf count _ = do+    buf' <- (unpackByteStringWithLength count) buf+    result <- _cb  buf'+    maybeReleaseFunPtr funptrptr+    let result' = (fromIntegral . fromEnum) result+    return result'++-- callback AttachmentSaveFunc+attachmentSaveFuncClosure :: AttachmentSaveFunc -> IO Closure+attachmentSaveFuncClosure cb = newCClosure =<< mkAttachmentSaveFunc wrapped+    where wrapped = attachmentSaveFuncWrapper Nothing cb++type AttachmentSaveFuncC =+    Ptr Word8 ->+    Word64 ->+    Ptr () ->+    IO CInt++foreign import ccall "wrapper"+    mkAttachmentSaveFunc :: AttachmentSaveFuncC -> IO (FunPtr AttachmentSaveFuncC)++type AttachmentSaveFunc =+    ByteString ->+    IO Bool++noAttachmentSaveFunc :: Maybe AttachmentSaveFunc+noAttachmentSaveFunc = Nothing++attachmentSaveFuncWrapper ::+    Maybe (Ptr (FunPtr (AttachmentSaveFuncC))) ->+    AttachmentSaveFunc ->+    Ptr Word8 ->+    Word64 ->+    Ptr () ->+    IO CInt+attachmentSaveFuncWrapper funptrptr _cb buf count _ = do+    buf' <- (unpackByteStringWithLength count) buf+    result <- _cb  buf'+    maybeReleaseFunPtr funptrptr+    let result' = (fromIntegral . fromEnum) result+    return result'++
+ GI/Poppler/Constants.hs view
@@ -0,0 +1,76 @@+{-# LANGUAGE PatternSynonyms, ScopedTypeVariables, ViewPatterns #-}++{- |+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.Constants+    ( +    pattern MINOR_VERSION                   ,+    pattern MICRO_VERSION                   ,+    pattern MAJOR_VERSION                   ,+    pattern HAS_CAIRO                       ,+    pattern ANNOT_TEXT_ICON_PARAGRAPH       ,+    pattern ANNOT_TEXT_ICON_NOTE            ,+    pattern ANNOT_TEXT_ICON_NEW_PARAGRAPH   ,+    pattern ANNOT_TEXT_ICON_KEY             ,+    pattern ANNOT_TEXT_ICON_INSERT          ,+    pattern ANNOT_TEXT_ICON_HELP            ,+    pattern ANNOT_TEXT_ICON_CROSS           ,+    pattern ANNOT_TEXT_ICON_COMMENT         ,+    pattern ANNOT_TEXT_ICON_CIRCLE          ,++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Poppler.Types+import GI.Poppler.Callbacks+++pattern MINOR_VERSION = 30 :: Int32+++pattern MICRO_VERSION = 0 :: Int32+++pattern MAJOR_VERSION = 0 :: Int32+++pattern HAS_CAIRO = 1 :: Int32+++pattern ANNOT_TEXT_ICON_PARAGRAPH = "Paragraph" :: T.Text+++pattern ANNOT_TEXT_ICON_NOTE = "Note" :: T.Text+++pattern ANNOT_TEXT_ICON_NEW_PARAGRAPH = "NewParagraph" :: T.Text+++pattern ANNOT_TEXT_ICON_KEY = "Key" :: T.Text+++pattern ANNOT_TEXT_ICON_INSERT = "Insert" :: T.Text+++pattern ANNOT_TEXT_ICON_HELP = "Help" :: T.Text+++pattern ANNOT_TEXT_ICON_CROSS = "Cross" :: T.Text+++pattern ANNOT_TEXT_ICON_COMMENT = "Comment" :: T.Text+++pattern ANNOT_TEXT_ICON_CIRCLE = "Circle" :: T.Text++
+ GI/Poppler/Enums.hs view
@@ -0,0 +1,1494 @@++{- |+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.Enums+    ( +    catchError                              ,+    handleError                             ,++-- * Exported types+    StructureWritingMode(..)                ,+    StructureTextDecoration(..)             ,+    StructureTextAlign(..)                  ,+    StructureTableScope(..)                 ,+    StructureRubyPosition(..)               ,+    StructureRubyAlign(..)                  ,+    StructurePlacement(..)                  ,+    StructureListNumbering(..)              ,+    StructureInlineAlign(..)                ,+    StructureGlyphOrientation(..)           ,+    StructureFormState(..)                  ,+    StructureFormRole(..)                   ,+    StructureElementKind(..)                ,+    StructureBorderStyle(..)                ,+    StructureBlockAlign(..)                 ,+    SelectionStyle(..)                      ,+    PageTransitionType(..)                  ,+    PageTransitionDirection(..)             ,+    PageTransitionAlignment(..)             ,+    PageMode(..)                            ,+    PageLayout(..)                          ,+    Orientation(..)                         ,+    FormTextType(..)                        ,+    FormFieldType(..)                       ,+    FormChoiceType(..)                      ,+    FormButtonType(..)                      ,+    FontType(..)                            ,+    Error(..)                               ,+    DestType(..)                            ,+    Backend(..)                             ,+    AnnotType(..)                           ,+    AnnotTextState(..)                      ,+    AnnotMarkupReplyType(..)                ,+    AnnotFreeTextQuadding(..)               ,+    AnnotExternalDataType(..)               ,+    ActionType(..)                          ,+    ActionMovieOperation(..)                ,+    ActionLayerAction(..)                   ,+++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map+++++-- Enum StructureWritingMode++data StructureWritingMode = +      StructureWritingModeLrTb+    | StructureWritingModeRlTb+    | StructureWritingModeTbRl+    | AnotherStructureWritingMode Int+    deriving (Show, Eq)++instance Enum StructureWritingMode where+    fromEnum StructureWritingModeLrTb = 0+    fromEnum StructureWritingModeRlTb = 1+    fromEnum StructureWritingModeTbRl = 2+    fromEnum (AnotherStructureWritingMode k) = k++    toEnum 0 = StructureWritingModeLrTb+    toEnum 1 = StructureWritingModeRlTb+    toEnum 2 = StructureWritingModeTbRl+    toEnum k = AnotherStructureWritingMode k++foreign import ccall "poppler_structure_writing_mode_get_type" c_poppler_structure_writing_mode_get_type :: +    IO GType++instance BoxedEnum StructureWritingMode where+    boxedEnumType _ = c_poppler_structure_writing_mode_get_type++-- Enum StructureTextDecoration++data StructureTextDecoration = +      StructureTextDecorationNone+    | StructureTextDecorationUnderline+    | StructureTextDecorationOverline+    | StructureTextDecorationLinethrough+    | AnotherStructureTextDecoration Int+    deriving (Show, Eq)++instance Enum StructureTextDecoration where+    fromEnum StructureTextDecorationNone = 0+    fromEnum StructureTextDecorationUnderline = 1+    fromEnum StructureTextDecorationOverline = 2+    fromEnum StructureTextDecorationLinethrough = 3+    fromEnum (AnotherStructureTextDecoration k) = k++    toEnum 0 = StructureTextDecorationNone+    toEnum 1 = StructureTextDecorationUnderline+    toEnum 2 = StructureTextDecorationOverline+    toEnum 3 = StructureTextDecorationLinethrough+    toEnum k = AnotherStructureTextDecoration k++foreign import ccall "poppler_structure_text_decoration_get_type" c_poppler_structure_text_decoration_get_type :: +    IO GType++instance BoxedEnum StructureTextDecoration where+    boxedEnumType _ = c_poppler_structure_text_decoration_get_type++-- Enum StructureTextAlign++data StructureTextAlign = +      StructureTextAlignStart+    | StructureTextAlignCenter+    | StructureTextAlignEnd+    | StructureTextAlignJustify+    | AnotherStructureTextAlign Int+    deriving (Show, Eq)++instance Enum StructureTextAlign where+    fromEnum StructureTextAlignStart = 0+    fromEnum StructureTextAlignCenter = 1+    fromEnum StructureTextAlignEnd = 2+    fromEnum StructureTextAlignJustify = 3+    fromEnum (AnotherStructureTextAlign k) = k++    toEnum 0 = StructureTextAlignStart+    toEnum 1 = StructureTextAlignCenter+    toEnum 2 = StructureTextAlignEnd+    toEnum 3 = StructureTextAlignJustify+    toEnum k = AnotherStructureTextAlign k++foreign import ccall "poppler_structure_text_align_get_type" c_poppler_structure_text_align_get_type :: +    IO GType++instance BoxedEnum StructureTextAlign where+    boxedEnumType _ = c_poppler_structure_text_align_get_type++-- Enum StructureTableScope++data StructureTableScope = +      StructureTableScopeRow+    | StructureTableScopeColumn+    | StructureTableScopeBoth+    | AnotherStructureTableScope Int+    deriving (Show, Eq)++instance Enum StructureTableScope where+    fromEnum StructureTableScopeRow = 0+    fromEnum StructureTableScopeColumn = 1+    fromEnum StructureTableScopeBoth = 2+    fromEnum (AnotherStructureTableScope k) = k++    toEnum 0 = StructureTableScopeRow+    toEnum 1 = StructureTableScopeColumn+    toEnum 2 = StructureTableScopeBoth+    toEnum k = AnotherStructureTableScope k++foreign import ccall "poppler_structure_table_scope_get_type" c_poppler_structure_table_scope_get_type :: +    IO GType++instance BoxedEnum StructureTableScope where+    boxedEnumType _ = c_poppler_structure_table_scope_get_type++-- Enum StructureRubyPosition++data StructureRubyPosition = +      StructureRubyPositionBefore+    | StructureRubyPositionAfter+    | StructureRubyPositionWarichu+    | StructureRubyPositionInline+    | AnotherStructureRubyPosition Int+    deriving (Show, Eq)++instance Enum StructureRubyPosition where+    fromEnum StructureRubyPositionBefore = 0+    fromEnum StructureRubyPositionAfter = 1+    fromEnum StructureRubyPositionWarichu = 2+    fromEnum StructureRubyPositionInline = 3+    fromEnum (AnotherStructureRubyPosition k) = k++    toEnum 0 = StructureRubyPositionBefore+    toEnum 1 = StructureRubyPositionAfter+    toEnum 2 = StructureRubyPositionWarichu+    toEnum 3 = StructureRubyPositionInline+    toEnum k = AnotherStructureRubyPosition k++foreign import ccall "poppler_structure_ruby_position_get_type" c_poppler_structure_ruby_position_get_type :: +    IO GType++instance BoxedEnum StructureRubyPosition where+    boxedEnumType _ = c_poppler_structure_ruby_position_get_type++-- Enum StructureRubyAlign++data StructureRubyAlign = +      StructureRubyAlignStart+    | StructureRubyAlignCenter+    | StructureRubyAlignEnd+    | StructureRubyAlignJustify+    | StructureRubyAlignDistribute+    | AnotherStructureRubyAlign Int+    deriving (Show, Eq)++instance Enum StructureRubyAlign where+    fromEnum StructureRubyAlignStart = 0+    fromEnum StructureRubyAlignCenter = 1+    fromEnum StructureRubyAlignEnd = 2+    fromEnum StructureRubyAlignJustify = 3+    fromEnum StructureRubyAlignDistribute = 4+    fromEnum (AnotherStructureRubyAlign k) = k++    toEnum 0 = StructureRubyAlignStart+    toEnum 1 = StructureRubyAlignCenter+    toEnum 2 = StructureRubyAlignEnd+    toEnum 3 = StructureRubyAlignJustify+    toEnum 4 = StructureRubyAlignDistribute+    toEnum k = AnotherStructureRubyAlign k++foreign import ccall "poppler_structure_ruby_align_get_type" c_poppler_structure_ruby_align_get_type :: +    IO GType++instance BoxedEnum StructureRubyAlign where+    boxedEnumType _ = c_poppler_structure_ruby_align_get_type++-- Enum StructurePlacement++data StructurePlacement = +      StructurePlacementBlock+    | StructurePlacementInline+    | StructurePlacementBefore+    | StructurePlacementStart+    | StructurePlacementEnd+    | AnotherStructurePlacement Int+    deriving (Show, Eq)++instance Enum StructurePlacement where+    fromEnum StructurePlacementBlock = 0+    fromEnum StructurePlacementInline = 1+    fromEnum StructurePlacementBefore = 2+    fromEnum StructurePlacementStart = 3+    fromEnum StructurePlacementEnd = 4+    fromEnum (AnotherStructurePlacement k) = k++    toEnum 0 = StructurePlacementBlock+    toEnum 1 = StructurePlacementInline+    toEnum 2 = StructurePlacementBefore+    toEnum 3 = StructurePlacementStart+    toEnum 4 = StructurePlacementEnd+    toEnum k = AnotherStructurePlacement k++foreign import ccall "poppler_structure_placement_get_type" c_poppler_structure_placement_get_type :: +    IO GType++instance BoxedEnum StructurePlacement where+    boxedEnumType _ = c_poppler_structure_placement_get_type++-- Enum StructureListNumbering++data StructureListNumbering = +      StructureListNumberingNone+    | StructureListNumberingDisc+    | StructureListNumberingCircle+    | StructureListNumberingSquare+    | StructureListNumberingDecimal+    | StructureListNumberingUpperRoman+    | StructureListNumberingLowerRoman+    | StructureListNumberingUpperAlpha+    | StructureListNumberingLowerAlpha+    | AnotherStructureListNumbering Int+    deriving (Show, Eq)++instance Enum StructureListNumbering where+    fromEnum StructureListNumberingNone = 0+    fromEnum StructureListNumberingDisc = 1+    fromEnum StructureListNumberingCircle = 2+    fromEnum StructureListNumberingSquare = 3+    fromEnum StructureListNumberingDecimal = 4+    fromEnum StructureListNumberingUpperRoman = 5+    fromEnum StructureListNumberingLowerRoman = 6+    fromEnum StructureListNumberingUpperAlpha = 7+    fromEnum StructureListNumberingLowerAlpha = 8+    fromEnum (AnotherStructureListNumbering k) = k++    toEnum 0 = StructureListNumberingNone+    toEnum 1 = StructureListNumberingDisc+    toEnum 2 = StructureListNumberingCircle+    toEnum 3 = StructureListNumberingSquare+    toEnum 4 = StructureListNumberingDecimal+    toEnum 5 = StructureListNumberingUpperRoman+    toEnum 6 = StructureListNumberingLowerRoman+    toEnum 7 = StructureListNumberingUpperAlpha+    toEnum 8 = StructureListNumberingLowerAlpha+    toEnum k = AnotherStructureListNumbering k++foreign import ccall "poppler_structure_list_numbering_get_type" c_poppler_structure_list_numbering_get_type :: +    IO GType++instance BoxedEnum StructureListNumbering where+    boxedEnumType _ = c_poppler_structure_list_numbering_get_type++-- Enum StructureInlineAlign++data StructureInlineAlign = +      StructureInlineAlignStart+    | StructureInlineAlignCenter+    | StructureInlineAlignEnd+    | AnotherStructureInlineAlign Int+    deriving (Show, Eq)++instance Enum StructureInlineAlign where+    fromEnum StructureInlineAlignStart = 0+    fromEnum StructureInlineAlignCenter = 1+    fromEnum StructureInlineAlignEnd = 2+    fromEnum (AnotherStructureInlineAlign k) = k++    toEnum 0 = StructureInlineAlignStart+    toEnum 1 = StructureInlineAlignCenter+    toEnum 2 = StructureInlineAlignEnd+    toEnum k = AnotherStructureInlineAlign k++foreign import ccall "poppler_structure_inline_align_get_type" c_poppler_structure_inline_align_get_type :: +    IO GType++instance BoxedEnum StructureInlineAlign where+    boxedEnumType _ = c_poppler_structure_inline_align_get_type++-- Enum StructureGlyphOrientation++data StructureGlyphOrientation = +      StructureGlyphOrientationAuto+    | StructureGlyphOrientation0+    | StructureGlyphOrientation90+    | StructureGlyphOrientation180+    | StructureGlyphOrientation270+    | AnotherStructureGlyphOrientation Int+    deriving (Show, Eq)++instance Enum StructureGlyphOrientation where+    fromEnum StructureGlyphOrientationAuto = 0+    fromEnum StructureGlyphOrientation0 = 0+    fromEnum StructureGlyphOrientation90 = 1+    fromEnum StructureGlyphOrientation180 = 2+    fromEnum StructureGlyphOrientation270 = 3+    fromEnum (AnotherStructureGlyphOrientation k) = k++    toEnum 0 = StructureGlyphOrientationAuto+    toEnum 1 = StructureGlyphOrientation90+    toEnum 2 = StructureGlyphOrientation180+    toEnum 3 = StructureGlyphOrientation270+    toEnum k = AnotherStructureGlyphOrientation k++foreign import ccall "poppler_structure_glyph_orientation_get_type" c_poppler_structure_glyph_orientation_get_type :: +    IO GType++instance BoxedEnum StructureGlyphOrientation where+    boxedEnumType _ = c_poppler_structure_glyph_orientation_get_type++-- Enum StructureFormState++data StructureFormState = +      StructureFormStateOn+    | StructureFormStateOff+    | StructureFormStateNeutral+    | AnotherStructureFormState Int+    deriving (Show, Eq)++instance Enum StructureFormState where+    fromEnum StructureFormStateOn = 0+    fromEnum StructureFormStateOff = 1+    fromEnum StructureFormStateNeutral = 2+    fromEnum (AnotherStructureFormState k) = k++    toEnum 0 = StructureFormStateOn+    toEnum 1 = StructureFormStateOff+    toEnum 2 = StructureFormStateNeutral+    toEnum k = AnotherStructureFormState k++foreign import ccall "poppler_structure_form_state_get_type" c_poppler_structure_form_state_get_type :: +    IO GType++instance BoxedEnum StructureFormState where+    boxedEnumType _ = c_poppler_structure_form_state_get_type++-- Enum StructureFormRole++data StructureFormRole = +      StructureFormRoleUndefined+    | StructureFormRoleRadioButton+    | StructureFormRolePushButton+    | StructureFormRoleTextValue+    | StructureFormRoleCheckbox+    | AnotherStructureFormRole Int+    deriving (Show, Eq)++instance Enum StructureFormRole where+    fromEnum StructureFormRoleUndefined = 0+    fromEnum StructureFormRoleRadioButton = 1+    fromEnum StructureFormRolePushButton = 2+    fromEnum StructureFormRoleTextValue = 3+    fromEnum StructureFormRoleCheckbox = 4+    fromEnum (AnotherStructureFormRole k) = k++    toEnum 0 = StructureFormRoleUndefined+    toEnum 1 = StructureFormRoleRadioButton+    toEnum 2 = StructureFormRolePushButton+    toEnum 3 = StructureFormRoleTextValue+    toEnum 4 = StructureFormRoleCheckbox+    toEnum k = AnotherStructureFormRole k++foreign import ccall "poppler_structure_form_role_get_type" c_poppler_structure_form_role_get_type :: +    IO GType++instance BoxedEnum StructureFormRole where+    boxedEnumType _ = c_poppler_structure_form_role_get_type++-- Enum StructureElementKind++data StructureElementKind = +      StructureElementKindContent+    | StructureElementKindObjectReference+    | StructureElementKindDocument+    | StructureElementKindPart+    | StructureElementKindArticle+    | StructureElementKindSection+    | StructureElementKindDiv+    | StructureElementKindSpan+    | StructureElementKindQuote+    | StructureElementKindNote+    | StructureElementKindReference+    | StructureElementKindBibentry+    | StructureElementKindCode+    | StructureElementKindLink+    | StructureElementKindAnnot+    | StructureElementKindBlockquote+    | StructureElementKindCaption+    | StructureElementKindNonstruct+    | StructureElementKindToc+    | StructureElementKindTocItem+    | StructureElementKindIndex+    | StructureElementKindPrivate+    | StructureElementKindParagraph+    | StructureElementKindHeading+    | StructureElementKindHeading1+    | StructureElementKindHeading2+    | StructureElementKindHeading3+    | StructureElementKindHeading4+    | StructureElementKindHeading5+    | StructureElementKindHeading6+    | StructureElementKindList+    | StructureElementKindListItem+    | StructureElementKindListLabel+    | StructureElementKindListBody+    | StructureElementKindTable+    | StructureElementKindTableRow+    | StructureElementKindTableHeading+    | StructureElementKindTableData+    | StructureElementKindTableHeader+    | StructureElementKindTableFooter+    | StructureElementKindTableBody+    | StructureElementKindRuby+    | StructureElementKindRubyBaseText+    | StructureElementKindRubyAnnotText+    | StructureElementKindRubyPunctuation+    | StructureElementKindWarichu+    | StructureElementKindWarichuText+    | StructureElementKindWarichuPunctuation+    | StructureElementKindFigure+    | StructureElementKindFormula+    | StructureElementKindForm+    | AnotherStructureElementKind Int+    deriving (Show, Eq)++instance Enum StructureElementKind where+    fromEnum StructureElementKindContent = 0+    fromEnum StructureElementKindObjectReference = 1+    fromEnum StructureElementKindDocument = 2+    fromEnum StructureElementKindPart = 3+    fromEnum StructureElementKindArticle = 4+    fromEnum StructureElementKindSection = 5+    fromEnum StructureElementKindDiv = 6+    fromEnum StructureElementKindSpan = 7+    fromEnum StructureElementKindQuote = 8+    fromEnum StructureElementKindNote = 9+    fromEnum StructureElementKindReference = 10+    fromEnum StructureElementKindBibentry = 11+    fromEnum StructureElementKindCode = 12+    fromEnum StructureElementKindLink = 13+    fromEnum StructureElementKindAnnot = 14+    fromEnum StructureElementKindBlockquote = 15+    fromEnum StructureElementKindCaption = 16+    fromEnum StructureElementKindNonstruct = 17+    fromEnum StructureElementKindToc = 18+    fromEnum StructureElementKindTocItem = 19+    fromEnum StructureElementKindIndex = 20+    fromEnum StructureElementKindPrivate = 21+    fromEnum StructureElementKindParagraph = 22+    fromEnum StructureElementKindHeading = 23+    fromEnum StructureElementKindHeading1 = 24+    fromEnum StructureElementKindHeading2 = 25+    fromEnum StructureElementKindHeading3 = 26+    fromEnum StructureElementKindHeading4 = 27+    fromEnum StructureElementKindHeading5 = 28+    fromEnum StructureElementKindHeading6 = 29+    fromEnum StructureElementKindList = 30+    fromEnum StructureElementKindListItem = 31+    fromEnum StructureElementKindListLabel = 32+    fromEnum StructureElementKindListBody = 33+    fromEnum StructureElementKindTable = 34+    fromEnum StructureElementKindTableRow = 35+    fromEnum StructureElementKindTableHeading = 36+    fromEnum StructureElementKindTableData = 37+    fromEnum StructureElementKindTableHeader = 38+    fromEnum StructureElementKindTableFooter = 39+    fromEnum StructureElementKindTableBody = 40+    fromEnum StructureElementKindRuby = 41+    fromEnum StructureElementKindRubyBaseText = 42+    fromEnum StructureElementKindRubyAnnotText = 43+    fromEnum StructureElementKindRubyPunctuation = 44+    fromEnum StructureElementKindWarichu = 45+    fromEnum StructureElementKindWarichuText = 46+    fromEnum StructureElementKindWarichuPunctuation = 47+    fromEnum StructureElementKindFigure = 48+    fromEnum StructureElementKindFormula = 49+    fromEnum StructureElementKindForm = 50+    fromEnum (AnotherStructureElementKind k) = k++    toEnum 0 = StructureElementKindContent+    toEnum 1 = StructureElementKindObjectReference+    toEnum 2 = StructureElementKindDocument+    toEnum 3 = StructureElementKindPart+    toEnum 4 = StructureElementKindArticle+    toEnum 5 = StructureElementKindSection+    toEnum 6 = StructureElementKindDiv+    toEnum 7 = StructureElementKindSpan+    toEnum 8 = StructureElementKindQuote+    toEnum 9 = StructureElementKindNote+    toEnum 10 = StructureElementKindReference+    toEnum 11 = StructureElementKindBibentry+    toEnum 12 = StructureElementKindCode+    toEnum 13 = StructureElementKindLink+    toEnum 14 = StructureElementKindAnnot+    toEnum 15 = StructureElementKindBlockquote+    toEnum 16 = StructureElementKindCaption+    toEnum 17 = StructureElementKindNonstruct+    toEnum 18 = StructureElementKindToc+    toEnum 19 = StructureElementKindTocItem+    toEnum 20 = StructureElementKindIndex+    toEnum 21 = StructureElementKindPrivate+    toEnum 22 = StructureElementKindParagraph+    toEnum 23 = StructureElementKindHeading+    toEnum 24 = StructureElementKindHeading1+    toEnum 25 = StructureElementKindHeading2+    toEnum 26 = StructureElementKindHeading3+    toEnum 27 = StructureElementKindHeading4+    toEnum 28 = StructureElementKindHeading5+    toEnum 29 = StructureElementKindHeading6+    toEnum 30 = StructureElementKindList+    toEnum 31 = StructureElementKindListItem+    toEnum 32 = StructureElementKindListLabel+    toEnum 33 = StructureElementKindListBody+    toEnum 34 = StructureElementKindTable+    toEnum 35 = StructureElementKindTableRow+    toEnum 36 = StructureElementKindTableHeading+    toEnum 37 = StructureElementKindTableData+    toEnum 38 = StructureElementKindTableHeader+    toEnum 39 = StructureElementKindTableFooter+    toEnum 40 = StructureElementKindTableBody+    toEnum 41 = StructureElementKindRuby+    toEnum 42 = StructureElementKindRubyBaseText+    toEnum 43 = StructureElementKindRubyAnnotText+    toEnum 44 = StructureElementKindRubyPunctuation+    toEnum 45 = StructureElementKindWarichu+    toEnum 46 = StructureElementKindWarichuText+    toEnum 47 = StructureElementKindWarichuPunctuation+    toEnum 48 = StructureElementKindFigure+    toEnum 49 = StructureElementKindFormula+    toEnum 50 = StructureElementKindForm+    toEnum k = AnotherStructureElementKind k++foreign import ccall "poppler_structure_element_kind_get_type" c_poppler_structure_element_kind_get_type :: +    IO GType++instance BoxedEnum StructureElementKind where+    boxedEnumType _ = c_poppler_structure_element_kind_get_type++-- Enum StructureBorderStyle++data StructureBorderStyle = +      StructureBorderStyleNone+    | StructureBorderStyleHidden+    | StructureBorderStyleDotted+    | StructureBorderStyleDashed+    | StructureBorderStyleSolid+    | StructureBorderStyleDouble+    | StructureBorderStyleGroove+    | StructureBorderStyleInset+    | StructureBorderStyleOutset+    | AnotherStructureBorderStyle Int+    deriving (Show, Eq)++instance Enum StructureBorderStyle where+    fromEnum StructureBorderStyleNone = 0+    fromEnum StructureBorderStyleHidden = 1+    fromEnum StructureBorderStyleDotted = 2+    fromEnum StructureBorderStyleDashed = 3+    fromEnum StructureBorderStyleSolid = 4+    fromEnum StructureBorderStyleDouble = 5+    fromEnum StructureBorderStyleGroove = 6+    fromEnum StructureBorderStyleInset = 7+    fromEnum StructureBorderStyleOutset = 8+    fromEnum (AnotherStructureBorderStyle k) = k++    toEnum 0 = StructureBorderStyleNone+    toEnum 1 = StructureBorderStyleHidden+    toEnum 2 = StructureBorderStyleDotted+    toEnum 3 = StructureBorderStyleDashed+    toEnum 4 = StructureBorderStyleSolid+    toEnum 5 = StructureBorderStyleDouble+    toEnum 6 = StructureBorderStyleGroove+    toEnum 7 = StructureBorderStyleInset+    toEnum 8 = StructureBorderStyleOutset+    toEnum k = AnotherStructureBorderStyle k++foreign import ccall "poppler_structure_border_style_get_type" c_poppler_structure_border_style_get_type :: +    IO GType++instance BoxedEnum StructureBorderStyle where+    boxedEnumType _ = c_poppler_structure_border_style_get_type++-- Enum StructureBlockAlign++data StructureBlockAlign = +      StructureBlockAlignBefore+    | StructureBlockAlignMiddle+    | StructureBlockAlignAfter+    | StructureBlockAlignJustify+    | AnotherStructureBlockAlign Int+    deriving (Show, Eq)++instance Enum StructureBlockAlign where+    fromEnum StructureBlockAlignBefore = 0+    fromEnum StructureBlockAlignMiddle = 1+    fromEnum StructureBlockAlignAfter = 2+    fromEnum StructureBlockAlignJustify = 3+    fromEnum (AnotherStructureBlockAlign k) = k++    toEnum 0 = StructureBlockAlignBefore+    toEnum 1 = StructureBlockAlignMiddle+    toEnum 2 = StructureBlockAlignAfter+    toEnum 3 = StructureBlockAlignJustify+    toEnum k = AnotherStructureBlockAlign k++foreign import ccall "poppler_structure_block_align_get_type" c_poppler_structure_block_align_get_type :: +    IO GType++instance BoxedEnum StructureBlockAlign where+    boxedEnumType _ = c_poppler_structure_block_align_get_type++-- Enum SelectionStyle++data SelectionStyle = +      SelectionStyleGlyph+    | SelectionStyleWord+    | SelectionStyleLine+    | AnotherSelectionStyle Int+    deriving (Show, Eq)++instance Enum SelectionStyle where+    fromEnum SelectionStyleGlyph = 0+    fromEnum SelectionStyleWord = 1+    fromEnum SelectionStyleLine = 2+    fromEnum (AnotherSelectionStyle k) = k++    toEnum 0 = SelectionStyleGlyph+    toEnum 1 = SelectionStyleWord+    toEnum 2 = SelectionStyleLine+    toEnum k = AnotherSelectionStyle k++foreign import ccall "poppler_selection_style_get_type" c_poppler_selection_style_get_type :: +    IO GType++instance BoxedEnum SelectionStyle where+    boxedEnumType _ = c_poppler_selection_style_get_type++-- Enum PageTransitionType++data PageTransitionType = +      PageTransitionTypeReplace+    | PageTransitionTypeSplit+    | PageTransitionTypeBlinds+    | PageTransitionTypeBox+    | PageTransitionTypeWipe+    | PageTransitionTypeDissolve+    | PageTransitionTypeGlitter+    | PageTransitionTypeFly+    | PageTransitionTypePush+    | PageTransitionTypeCover+    | PageTransitionTypeUncover+    | PageTransitionTypeFade+    | AnotherPageTransitionType Int+    deriving (Show, Eq)++instance Enum PageTransitionType where+    fromEnum PageTransitionTypeReplace = 0+    fromEnum PageTransitionTypeSplit = 1+    fromEnum PageTransitionTypeBlinds = 2+    fromEnum PageTransitionTypeBox = 3+    fromEnum PageTransitionTypeWipe = 4+    fromEnum PageTransitionTypeDissolve = 5+    fromEnum PageTransitionTypeGlitter = 6+    fromEnum PageTransitionTypeFly = 7+    fromEnum PageTransitionTypePush = 8+    fromEnum PageTransitionTypeCover = 9+    fromEnum PageTransitionTypeUncover = 10+    fromEnum PageTransitionTypeFade = 11+    fromEnum (AnotherPageTransitionType k) = k++    toEnum 0 = PageTransitionTypeReplace+    toEnum 1 = PageTransitionTypeSplit+    toEnum 2 = PageTransitionTypeBlinds+    toEnum 3 = PageTransitionTypeBox+    toEnum 4 = PageTransitionTypeWipe+    toEnum 5 = PageTransitionTypeDissolve+    toEnum 6 = PageTransitionTypeGlitter+    toEnum 7 = PageTransitionTypeFly+    toEnum 8 = PageTransitionTypePush+    toEnum 9 = PageTransitionTypeCover+    toEnum 10 = PageTransitionTypeUncover+    toEnum 11 = PageTransitionTypeFade+    toEnum k = AnotherPageTransitionType k++foreign import ccall "poppler_page_transition_type_get_type" c_poppler_page_transition_type_get_type :: +    IO GType++instance BoxedEnum PageTransitionType where+    boxedEnumType _ = c_poppler_page_transition_type_get_type++-- Enum PageTransitionDirection++data PageTransitionDirection = +      PageTransitionDirectionInward+    | PageTransitionDirectionOutward+    | AnotherPageTransitionDirection Int+    deriving (Show, Eq)++instance Enum PageTransitionDirection where+    fromEnum PageTransitionDirectionInward = 0+    fromEnum PageTransitionDirectionOutward = 1+    fromEnum (AnotherPageTransitionDirection k) = k++    toEnum 0 = PageTransitionDirectionInward+    toEnum 1 = PageTransitionDirectionOutward+    toEnum k = AnotherPageTransitionDirection k++foreign import ccall "poppler_page_transition_direction_get_type" c_poppler_page_transition_direction_get_type :: +    IO GType++instance BoxedEnum PageTransitionDirection where+    boxedEnumType _ = c_poppler_page_transition_direction_get_type++-- Enum PageTransitionAlignment++data PageTransitionAlignment = +      PageTransitionAlignmentHorizontal+    | PageTransitionAlignmentVertical+    | AnotherPageTransitionAlignment Int+    deriving (Show, Eq)++instance Enum PageTransitionAlignment where+    fromEnum PageTransitionAlignmentHorizontal = 0+    fromEnum PageTransitionAlignmentVertical = 1+    fromEnum (AnotherPageTransitionAlignment k) = k++    toEnum 0 = PageTransitionAlignmentHorizontal+    toEnum 1 = PageTransitionAlignmentVertical+    toEnum k = AnotherPageTransitionAlignment k++foreign import ccall "poppler_page_transition_alignment_get_type" c_poppler_page_transition_alignment_get_type :: +    IO GType++instance BoxedEnum PageTransitionAlignment where+    boxedEnumType _ = c_poppler_page_transition_alignment_get_type++-- Enum PageMode++data PageMode = +      PageModeUnset+    | PageModeNone+    | PageModeUseOutlines+    | PageModeUseThumbs+    | PageModeFullScreen+    | PageModeUseOc+    | PageModeUseAttachments+    | AnotherPageMode Int+    deriving (Show, Eq)++instance Enum PageMode where+    fromEnum PageModeUnset = 0+    fromEnum PageModeNone = 1+    fromEnum PageModeUseOutlines = 2+    fromEnum PageModeUseThumbs = 3+    fromEnum PageModeFullScreen = 4+    fromEnum PageModeUseOc = 5+    fromEnum PageModeUseAttachments = 6+    fromEnum (AnotherPageMode k) = k++    toEnum 0 = PageModeUnset+    toEnum 1 = PageModeNone+    toEnum 2 = PageModeUseOutlines+    toEnum 3 = PageModeUseThumbs+    toEnum 4 = PageModeFullScreen+    toEnum 5 = PageModeUseOc+    toEnum 6 = PageModeUseAttachments+    toEnum k = AnotherPageMode k++foreign import ccall "poppler_page_mode_get_type" c_poppler_page_mode_get_type :: +    IO GType++instance BoxedEnum PageMode where+    boxedEnumType _ = c_poppler_page_mode_get_type++-- Enum PageLayout++data PageLayout = +      PageLayoutUnset+    | PageLayoutSinglePage+    | PageLayoutOneColumn+    | PageLayoutTwoColumnLeft+    | PageLayoutTwoColumnRight+    | PageLayoutTwoPageLeft+    | PageLayoutTwoPageRight+    | AnotherPageLayout Int+    deriving (Show, Eq)++instance Enum PageLayout where+    fromEnum PageLayoutUnset = 0+    fromEnum PageLayoutSinglePage = 1+    fromEnum PageLayoutOneColumn = 2+    fromEnum PageLayoutTwoColumnLeft = 3+    fromEnum PageLayoutTwoColumnRight = 4+    fromEnum PageLayoutTwoPageLeft = 5+    fromEnum PageLayoutTwoPageRight = 6+    fromEnum (AnotherPageLayout k) = k++    toEnum 0 = PageLayoutUnset+    toEnum 1 = PageLayoutSinglePage+    toEnum 2 = PageLayoutOneColumn+    toEnum 3 = PageLayoutTwoColumnLeft+    toEnum 4 = PageLayoutTwoColumnRight+    toEnum 5 = PageLayoutTwoPageLeft+    toEnum 6 = PageLayoutTwoPageRight+    toEnum k = AnotherPageLayout k++foreign import ccall "poppler_page_layout_get_type" c_poppler_page_layout_get_type :: +    IO GType++instance BoxedEnum PageLayout where+    boxedEnumType _ = c_poppler_page_layout_get_type++-- Enum Orientation++data Orientation = +      OrientationPortrait+    | OrientationLandscape+    | OrientationUpsidedown+    | OrientationSeascape+    | AnotherOrientation Int+    deriving (Show, Eq)++instance Enum Orientation where+    fromEnum OrientationPortrait = 0+    fromEnum OrientationLandscape = 1+    fromEnum OrientationUpsidedown = 2+    fromEnum OrientationSeascape = 3+    fromEnum (AnotherOrientation k) = k++    toEnum 0 = OrientationPortrait+    toEnum 1 = OrientationLandscape+    toEnum 2 = OrientationUpsidedown+    toEnum 3 = OrientationSeascape+    toEnum k = AnotherOrientation k++foreign import ccall "poppler_orientation_get_type" c_poppler_orientation_get_type :: +    IO GType++instance BoxedEnum Orientation where+    boxedEnumType _ = c_poppler_orientation_get_type++-- Enum FormTextType++data FormTextType = +      FormTextTypeNormal+    | FormTextTypeMultiline+    | FormTextTypeFileSelect+    | AnotherFormTextType Int+    deriving (Show, Eq)++instance Enum FormTextType where+    fromEnum FormTextTypeNormal = 0+    fromEnum FormTextTypeMultiline = 1+    fromEnum FormTextTypeFileSelect = 2+    fromEnum (AnotherFormTextType k) = k++    toEnum 0 = FormTextTypeNormal+    toEnum 1 = FormTextTypeMultiline+    toEnum 2 = FormTextTypeFileSelect+    toEnum k = AnotherFormTextType k++foreign import ccall "poppler_form_text_type_get_type" c_poppler_form_text_type_get_type :: +    IO GType++instance BoxedEnum FormTextType where+    boxedEnumType _ = c_poppler_form_text_type_get_type++-- Enum FormFieldType++data FormFieldType = +      FormFieldTypeUnknown+    | FormFieldTypeButton+    | FormFieldTypeText+    | FormFieldTypeChoice+    | FormFieldTypeSignature+    | AnotherFormFieldType Int+    deriving (Show, Eq)++instance Enum FormFieldType where+    fromEnum FormFieldTypeUnknown = 0+    fromEnum FormFieldTypeButton = 1+    fromEnum FormFieldTypeText = 2+    fromEnum FormFieldTypeChoice = 3+    fromEnum FormFieldTypeSignature = 4+    fromEnum (AnotherFormFieldType k) = k++    toEnum 0 = FormFieldTypeUnknown+    toEnum 1 = FormFieldTypeButton+    toEnum 2 = FormFieldTypeText+    toEnum 3 = FormFieldTypeChoice+    toEnum 4 = FormFieldTypeSignature+    toEnum k = AnotherFormFieldType k++foreign import ccall "poppler_form_field_type_get_type" c_poppler_form_field_type_get_type :: +    IO GType++instance BoxedEnum FormFieldType where+    boxedEnumType _ = c_poppler_form_field_type_get_type++-- Enum FormChoiceType++data FormChoiceType = +      FormChoiceTypeCombo+    | FormChoiceTypeList+    | AnotherFormChoiceType Int+    deriving (Show, Eq)++instance Enum FormChoiceType where+    fromEnum FormChoiceTypeCombo = 0+    fromEnum FormChoiceTypeList = 1+    fromEnum (AnotherFormChoiceType k) = k++    toEnum 0 = FormChoiceTypeCombo+    toEnum 1 = FormChoiceTypeList+    toEnum k = AnotherFormChoiceType k++foreign import ccall "poppler_form_choice_type_get_type" c_poppler_form_choice_type_get_type :: +    IO GType++instance BoxedEnum FormChoiceType where+    boxedEnumType _ = c_poppler_form_choice_type_get_type++-- Enum FormButtonType++data FormButtonType = +      FormButtonTypePush+    | FormButtonTypeCheck+    | FormButtonTypeRadio+    | AnotherFormButtonType Int+    deriving (Show, Eq)++instance Enum FormButtonType where+    fromEnum FormButtonTypePush = 0+    fromEnum FormButtonTypeCheck = 1+    fromEnum FormButtonTypeRadio = 2+    fromEnum (AnotherFormButtonType k) = k++    toEnum 0 = FormButtonTypePush+    toEnum 1 = FormButtonTypeCheck+    toEnum 2 = FormButtonTypeRadio+    toEnum k = AnotherFormButtonType k++foreign import ccall "poppler_form_button_type_get_type" c_poppler_form_button_type_get_type :: +    IO GType++instance BoxedEnum FormButtonType where+    boxedEnumType _ = c_poppler_form_button_type_get_type++-- Enum FontType++data FontType = +      FontTypeUnknown+    | FontTypeType1+    | FontTypeType1c+    | FontTypeType1cot+    | FontTypeType3+    | FontTypeTruetype+    | FontTypeTruetypeot+    | FontTypeCidType0+    | FontTypeCidType0c+    | FontTypeCidType0cot+    | FontTypeCidType2+    | FontTypeCidType2ot+    | AnotherFontType Int+    deriving (Show, Eq)++instance Enum FontType where+    fromEnum FontTypeUnknown = 0+    fromEnum FontTypeType1 = 1+    fromEnum FontTypeType1c = 2+    fromEnum FontTypeType1cot = 3+    fromEnum FontTypeType3 = 4+    fromEnum FontTypeTruetype = 5+    fromEnum FontTypeTruetypeot = 6+    fromEnum FontTypeCidType0 = 7+    fromEnum FontTypeCidType0c = 8+    fromEnum FontTypeCidType0cot = 9+    fromEnum FontTypeCidType2 = 10+    fromEnum FontTypeCidType2ot = 11+    fromEnum (AnotherFontType k) = k++    toEnum 0 = FontTypeUnknown+    toEnum 1 = FontTypeType1+    toEnum 2 = FontTypeType1c+    toEnum 3 = FontTypeType1cot+    toEnum 4 = FontTypeType3+    toEnum 5 = FontTypeTruetype+    toEnum 6 = FontTypeTruetypeot+    toEnum 7 = FontTypeCidType0+    toEnum 8 = FontTypeCidType0c+    toEnum 9 = FontTypeCidType0cot+    toEnum 10 = FontTypeCidType2+    toEnum 11 = FontTypeCidType2ot+    toEnum k = AnotherFontType k++foreign import ccall "poppler_font_type_get_type" c_poppler_font_type_get_type :: +    IO GType++instance BoxedEnum FontType where+    boxedEnumType _ = c_poppler_font_type_get_type++-- Enum Error++data Error = +      ErrorInvalid+    | ErrorEncrypted+    | ErrorOpenFile+    | ErrorBadCatalog+    | ErrorDamaged+    | AnotherError Int+    deriving (Show, Eq)++instance Enum Error where+    fromEnum ErrorInvalid = 0+    fromEnum ErrorEncrypted = 1+    fromEnum ErrorOpenFile = 2+    fromEnum ErrorBadCatalog = 3+    fromEnum ErrorDamaged = 4+    fromEnum (AnotherError k) = k++    toEnum 0 = ErrorInvalid+    toEnum 1 = ErrorEncrypted+    toEnum 2 = ErrorOpenFile+    toEnum 3 = ErrorBadCatalog+    toEnum 4 = ErrorDamaged+    toEnum k = AnotherError k++instance GErrorClass Error where+    gerrorClassDomain _ = "poppler-quark"++catchError ::+    IO a ->+    (Error -> GErrorMessage -> IO a) ->+    IO a+catchError = catchGErrorJustDomain++handleError ::+    (Error -> GErrorMessage -> IO a) ->+    IO a ->+    IO a+handleError = handleGErrorJustDomain++foreign import ccall "poppler_error_get_type" c_poppler_error_get_type :: +    IO GType++instance BoxedEnum Error where+    boxedEnumType _ = c_poppler_error_get_type++-- Enum DestType++data DestType = +      DestTypeUnknown+    | DestTypeXyz+    | DestTypeFit+    | DestTypeFith+    | DestTypeFitv+    | DestTypeFitr+    | DestTypeFitb+    | DestTypeFitbh+    | DestTypeFitbv+    | DestTypeNamed+    | AnotherDestType Int+    deriving (Show, Eq)++instance Enum DestType where+    fromEnum DestTypeUnknown = 0+    fromEnum DestTypeXyz = 1+    fromEnum DestTypeFit = 2+    fromEnum DestTypeFith = 3+    fromEnum DestTypeFitv = 4+    fromEnum DestTypeFitr = 5+    fromEnum DestTypeFitb = 6+    fromEnum DestTypeFitbh = 7+    fromEnum DestTypeFitbv = 8+    fromEnum DestTypeNamed = 9+    fromEnum (AnotherDestType k) = k++    toEnum 0 = DestTypeUnknown+    toEnum 1 = DestTypeXyz+    toEnum 2 = DestTypeFit+    toEnum 3 = DestTypeFith+    toEnum 4 = DestTypeFitv+    toEnum 5 = DestTypeFitr+    toEnum 6 = DestTypeFitb+    toEnum 7 = DestTypeFitbh+    toEnum 8 = DestTypeFitbv+    toEnum 9 = DestTypeNamed+    toEnum k = AnotherDestType k++foreign import ccall "poppler_dest_type_get_type" c_poppler_dest_type_get_type :: +    IO GType++instance BoxedEnum DestType where+    boxedEnumType _ = c_poppler_dest_type_get_type++-- Enum Backend++data Backend = +      BackendUnknown+    | BackendSplash+    | BackendCairo+    | AnotherBackend Int+    deriving (Show, Eq)++instance Enum Backend where+    fromEnum BackendUnknown = 0+    fromEnum BackendSplash = 1+    fromEnum BackendCairo = 2+    fromEnum (AnotherBackend k) = k++    toEnum 0 = BackendUnknown+    toEnum 1 = BackendSplash+    toEnum 2 = BackendCairo+    toEnum k = AnotherBackend k++foreign import ccall "poppler_backend_get_type" c_poppler_backend_get_type :: +    IO GType++instance BoxedEnum Backend where+    boxedEnumType _ = c_poppler_backend_get_type++-- Enum AnnotType++data AnnotType = +      AnnotTypeUnknown+    | AnnotTypeText+    | AnnotTypeLink+    | AnnotTypeFreeText+    | AnnotTypeLine+    | AnnotTypeSquare+    | AnnotTypeCircle+    | AnnotTypePolygon+    | AnnotTypePolyLine+    | AnnotTypeHighlight+    | AnnotTypeUnderline+    | AnnotTypeSquiggly+    | AnnotTypeStrikeOut+    | AnnotTypeStamp+    | AnnotTypeCaret+    | AnnotTypeInk+    | AnnotTypePopup+    | AnnotTypeFileAttachment+    | AnnotTypeSound+    | AnnotTypeMovie+    | AnnotTypeWidget+    | AnnotTypeScreen+    | AnnotTypePrinterMark+    | AnnotTypeTrapNet+    | AnnotTypeWatermark+    | AnnotType3d+    | AnotherAnnotType Int+    deriving (Show, Eq)++instance Enum AnnotType where+    fromEnum AnnotTypeUnknown = 0+    fromEnum AnnotTypeText = 1+    fromEnum AnnotTypeLink = 2+    fromEnum AnnotTypeFreeText = 3+    fromEnum AnnotTypeLine = 4+    fromEnum AnnotTypeSquare = 5+    fromEnum AnnotTypeCircle = 6+    fromEnum AnnotTypePolygon = 7+    fromEnum AnnotTypePolyLine = 8+    fromEnum AnnotTypeHighlight = 9+    fromEnum AnnotTypeUnderline = 10+    fromEnum AnnotTypeSquiggly = 11+    fromEnum AnnotTypeStrikeOut = 12+    fromEnum AnnotTypeStamp = 13+    fromEnum AnnotTypeCaret = 14+    fromEnum AnnotTypeInk = 15+    fromEnum AnnotTypePopup = 16+    fromEnum AnnotTypeFileAttachment = 17+    fromEnum AnnotTypeSound = 18+    fromEnum AnnotTypeMovie = 19+    fromEnum AnnotTypeWidget = 20+    fromEnum AnnotTypeScreen = 21+    fromEnum AnnotTypePrinterMark = 22+    fromEnum AnnotTypeTrapNet = 23+    fromEnum AnnotTypeWatermark = 24+    fromEnum AnnotType3d = 25+    fromEnum (AnotherAnnotType k) = k++    toEnum 0 = AnnotTypeUnknown+    toEnum 1 = AnnotTypeText+    toEnum 2 = AnnotTypeLink+    toEnum 3 = AnnotTypeFreeText+    toEnum 4 = AnnotTypeLine+    toEnum 5 = AnnotTypeSquare+    toEnum 6 = AnnotTypeCircle+    toEnum 7 = AnnotTypePolygon+    toEnum 8 = AnnotTypePolyLine+    toEnum 9 = AnnotTypeHighlight+    toEnum 10 = AnnotTypeUnderline+    toEnum 11 = AnnotTypeSquiggly+    toEnum 12 = AnnotTypeStrikeOut+    toEnum 13 = AnnotTypeStamp+    toEnum 14 = AnnotTypeCaret+    toEnum 15 = AnnotTypeInk+    toEnum 16 = AnnotTypePopup+    toEnum 17 = AnnotTypeFileAttachment+    toEnum 18 = AnnotTypeSound+    toEnum 19 = AnnotTypeMovie+    toEnum 20 = AnnotTypeWidget+    toEnum 21 = AnnotTypeScreen+    toEnum 22 = AnnotTypePrinterMark+    toEnum 23 = AnnotTypeTrapNet+    toEnum 24 = AnnotTypeWatermark+    toEnum 25 = AnnotType3d+    toEnum k = AnotherAnnotType k++foreign import ccall "poppler_annot_type_get_type" c_poppler_annot_type_get_type :: +    IO GType++instance BoxedEnum AnnotType where+    boxedEnumType _ = c_poppler_annot_type_get_type++-- Enum AnnotTextState++data AnnotTextState = +      AnnotTextStateMarked+    | AnnotTextStateUnmarked+    | AnnotTextStateAccepted+    | AnnotTextStateRejected+    | AnnotTextStateCancelled+    | AnnotTextStateCompleted+    | AnnotTextStateNone+    | AnnotTextStateUnknown+    | AnotherAnnotTextState Int+    deriving (Show, Eq)++instance Enum AnnotTextState where+    fromEnum AnnotTextStateMarked = 0+    fromEnum AnnotTextStateUnmarked = 1+    fromEnum AnnotTextStateAccepted = 2+    fromEnum AnnotTextStateRejected = 3+    fromEnum AnnotTextStateCancelled = 4+    fromEnum AnnotTextStateCompleted = 5+    fromEnum AnnotTextStateNone = 6+    fromEnum AnnotTextStateUnknown = 7+    fromEnum (AnotherAnnotTextState k) = k++    toEnum 0 = AnnotTextStateMarked+    toEnum 1 = AnnotTextStateUnmarked+    toEnum 2 = AnnotTextStateAccepted+    toEnum 3 = AnnotTextStateRejected+    toEnum 4 = AnnotTextStateCancelled+    toEnum 5 = AnnotTextStateCompleted+    toEnum 6 = AnnotTextStateNone+    toEnum 7 = AnnotTextStateUnknown+    toEnum k = AnotherAnnotTextState k++foreign import ccall "poppler_annot_text_state_get_type" c_poppler_annot_text_state_get_type :: +    IO GType++instance BoxedEnum AnnotTextState where+    boxedEnumType _ = c_poppler_annot_text_state_get_type++-- Enum AnnotMarkupReplyType++data AnnotMarkupReplyType = +      AnnotMarkupReplyTypeR+    | AnnotMarkupReplyTypeGroup+    | AnotherAnnotMarkupReplyType Int+    deriving (Show, Eq)++instance Enum AnnotMarkupReplyType where+    fromEnum AnnotMarkupReplyTypeR = 0+    fromEnum AnnotMarkupReplyTypeGroup = 1+    fromEnum (AnotherAnnotMarkupReplyType k) = k++    toEnum 0 = AnnotMarkupReplyTypeR+    toEnum 1 = AnnotMarkupReplyTypeGroup+    toEnum k = AnotherAnnotMarkupReplyType k++foreign import ccall "poppler_annot_markup_reply_type_get_type" c_poppler_annot_markup_reply_type_get_type :: +    IO GType++instance BoxedEnum AnnotMarkupReplyType where+    boxedEnumType _ = c_poppler_annot_markup_reply_type_get_type++-- Enum AnnotFreeTextQuadding++data AnnotFreeTextQuadding = +      AnnotFreeTextQuaddingLeftJustified+    | AnnotFreeTextQuaddingCentered+    | AnnotFreeTextQuaddingRightJustified+    | AnotherAnnotFreeTextQuadding Int+    deriving (Show, Eq)++instance Enum AnnotFreeTextQuadding where+    fromEnum AnnotFreeTextQuaddingLeftJustified = 0+    fromEnum AnnotFreeTextQuaddingCentered = 1+    fromEnum AnnotFreeTextQuaddingRightJustified = 2+    fromEnum (AnotherAnnotFreeTextQuadding k) = k++    toEnum 0 = AnnotFreeTextQuaddingLeftJustified+    toEnum 1 = AnnotFreeTextQuaddingCentered+    toEnum 2 = AnnotFreeTextQuaddingRightJustified+    toEnum k = AnotherAnnotFreeTextQuadding k++foreign import ccall "poppler_annot_free_text_quadding_get_type" c_poppler_annot_free_text_quadding_get_type :: +    IO GType++instance BoxedEnum AnnotFreeTextQuadding where+    boxedEnumType _ = c_poppler_annot_free_text_quadding_get_type++-- Enum AnnotExternalDataType++data AnnotExternalDataType = +      AnnotExternalDataType3d+    | AnnotExternalDataTypeUnknown+    | AnotherAnnotExternalDataType Int+    deriving (Show, Eq)++instance Enum AnnotExternalDataType where+    fromEnum AnnotExternalDataType3d = 0+    fromEnum AnnotExternalDataTypeUnknown = 1+    fromEnum (AnotherAnnotExternalDataType k) = k++    toEnum 0 = AnnotExternalDataType3d+    toEnum 1 = AnnotExternalDataTypeUnknown+    toEnum k = AnotherAnnotExternalDataType k++foreign import ccall "poppler_annot_external_data_type_get_type" c_poppler_annot_external_data_type_get_type :: +    IO GType++instance BoxedEnum AnnotExternalDataType where+    boxedEnumType _ = c_poppler_annot_external_data_type_get_type++-- Enum ActionType++data ActionType = +      ActionTypeUnknown+    | ActionTypeNone+    | ActionTypeGotoDest+    | ActionTypeGotoRemote+    | ActionTypeLaunch+    | ActionTypeUri+    | ActionTypeNamed+    | ActionTypeMovie+    | ActionTypeRendition+    | ActionTypeOcgState+    | ActionTypeJavascript+    | AnotherActionType Int+    deriving (Show, Eq)++instance Enum ActionType where+    fromEnum ActionTypeUnknown = 0+    fromEnum ActionTypeNone = 1+    fromEnum ActionTypeGotoDest = 2+    fromEnum ActionTypeGotoRemote = 3+    fromEnum ActionTypeLaunch = 4+    fromEnum ActionTypeUri = 5+    fromEnum ActionTypeNamed = 6+    fromEnum ActionTypeMovie = 7+    fromEnum ActionTypeRendition = 8+    fromEnum ActionTypeOcgState = 9+    fromEnum ActionTypeJavascript = 10+    fromEnum (AnotherActionType k) = k++    toEnum 0 = ActionTypeUnknown+    toEnum 1 = ActionTypeNone+    toEnum 2 = ActionTypeGotoDest+    toEnum 3 = ActionTypeGotoRemote+    toEnum 4 = ActionTypeLaunch+    toEnum 5 = ActionTypeUri+    toEnum 6 = ActionTypeNamed+    toEnum 7 = ActionTypeMovie+    toEnum 8 = ActionTypeRendition+    toEnum 9 = ActionTypeOcgState+    toEnum 10 = ActionTypeJavascript+    toEnum k = AnotherActionType k++foreign import ccall "poppler_action_type_get_type" c_poppler_action_type_get_type :: +    IO GType++instance BoxedEnum ActionType where+    boxedEnumType _ = c_poppler_action_type_get_type++-- Enum ActionMovieOperation++data ActionMovieOperation = +      ActionMovieOperationPlay+    | ActionMovieOperationPause+    | ActionMovieOperationResume+    | ActionMovieOperationStop+    | AnotherActionMovieOperation Int+    deriving (Show, Eq)++instance Enum ActionMovieOperation where+    fromEnum ActionMovieOperationPlay = 0+    fromEnum ActionMovieOperationPause = 1+    fromEnum ActionMovieOperationResume = 2+    fromEnum ActionMovieOperationStop = 3+    fromEnum (AnotherActionMovieOperation k) = k++    toEnum 0 = ActionMovieOperationPlay+    toEnum 1 = ActionMovieOperationPause+    toEnum 2 = ActionMovieOperationResume+    toEnum 3 = ActionMovieOperationStop+    toEnum k = AnotherActionMovieOperation k++foreign import ccall "poppler_action_movie_operation_get_type" c_poppler_action_movie_operation_get_type :: +    IO GType++instance BoxedEnum ActionMovieOperation where+    boxedEnumType _ = c_poppler_action_movie_operation_get_type++-- Enum ActionLayerAction++data ActionLayerAction = +      ActionLayerActionOn+    | ActionLayerActionOff+    | ActionLayerActionToggle+    | AnotherActionLayerAction Int+    deriving (Show, Eq)++instance Enum ActionLayerAction where+    fromEnum ActionLayerActionOn = 0+    fromEnum ActionLayerActionOff = 1+    fromEnum ActionLayerActionToggle = 2+    fromEnum (AnotherActionLayerAction k) = k++    toEnum 0 = ActionLayerActionOn+    toEnum 1 = ActionLayerActionOff+    toEnum 2 = ActionLayerActionToggle+    toEnum k = AnotherActionLayerAction k++foreign import ccall "poppler_action_layer_action_get_type" c_poppler_action_layer_action_get_type :: +    IO GType++instance BoxedEnum ActionLayerAction where+    boxedEnumType _ = c_poppler_action_layer_action_get_type++
+ GI/Poppler/Flags.hs view
@@ -0,0 +1,259 @@++{- |+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.Flags+    ( ++-- * Exported types+    ViewerPreferences(..)                   ,+    StructureGetTextFlags(..)               ,+    PrintFlags(..)                          ,+    Permissions(..)                         ,+    FindFlags(..)                           ,+    AnnotFlag(..)                           ,+++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map+++++-- Flags ViewerPreferences++data ViewerPreferences = +      ViewerPreferencesUnset+    | ViewerPreferencesHideToolbar+    | ViewerPreferencesHideMenubar+    | ViewerPreferencesHideWindowui+    | ViewerPreferencesFitWindow+    | ViewerPreferencesCenterWindow+    | ViewerPreferencesDisplayDocTitle+    | ViewerPreferencesDirectionRtl+    | AnotherViewerPreferences Int+    deriving (Show, Eq)++instance Enum ViewerPreferences where+    fromEnum ViewerPreferencesUnset = 0+    fromEnum ViewerPreferencesHideToolbar = 1+    fromEnum ViewerPreferencesHideMenubar = 2+    fromEnum ViewerPreferencesHideWindowui = 4+    fromEnum ViewerPreferencesFitWindow = 8+    fromEnum ViewerPreferencesCenterWindow = 16+    fromEnum ViewerPreferencesDisplayDocTitle = 32+    fromEnum ViewerPreferencesDirectionRtl = 64+    fromEnum (AnotherViewerPreferences k) = k++    toEnum 0 = ViewerPreferencesUnset+    toEnum 1 = ViewerPreferencesHideToolbar+    toEnum 2 = ViewerPreferencesHideMenubar+    toEnum 4 = ViewerPreferencesHideWindowui+    toEnum 8 = ViewerPreferencesFitWindow+    toEnum 16 = ViewerPreferencesCenterWindow+    toEnum 32 = ViewerPreferencesDisplayDocTitle+    toEnum 64 = ViewerPreferencesDirectionRtl+    toEnum k = AnotherViewerPreferences k++foreign import ccall "poppler_viewer_preferences_get_type" c_poppler_viewer_preferences_get_type :: +    IO GType++instance BoxedEnum ViewerPreferences where+    boxedEnumType _ = c_poppler_viewer_preferences_get_type++instance IsGFlag ViewerPreferences++-- Flags StructureGetTextFlags++data StructureGetTextFlags = +      StructureGetTextFlagsNone+    | StructureGetTextFlagsRecursive+    | AnotherStructureGetTextFlags Int+    deriving (Show, Eq)++instance Enum StructureGetTextFlags where+    fromEnum StructureGetTextFlagsNone = 0+    fromEnum StructureGetTextFlagsRecursive = 1+    fromEnum (AnotherStructureGetTextFlags k) = k++    toEnum 0 = StructureGetTextFlagsNone+    toEnum 1 = StructureGetTextFlagsRecursive+    toEnum k = AnotherStructureGetTextFlags k++foreign import ccall "poppler_structure_get_text_flags_get_type" c_poppler_structure_get_text_flags_get_type :: +    IO GType++instance BoxedEnum StructureGetTextFlags where+    boxedEnumType _ = c_poppler_structure_get_text_flags_get_type++instance IsGFlag StructureGetTextFlags++-- Flags PrintFlags++data PrintFlags = +      PrintFlagsDocument+    | PrintFlagsMarkupAnnots+    | PrintFlagsStampAnnotsOnly+    | PrintFlagsAll+    | AnotherPrintFlags Int+    deriving (Show, Eq)++instance Enum PrintFlags where+    fromEnum PrintFlagsDocument = 0+    fromEnum PrintFlagsMarkupAnnots = 1+    fromEnum PrintFlagsStampAnnotsOnly = 2+    fromEnum PrintFlagsAll = 1+    fromEnum (AnotherPrintFlags k) = k++    toEnum 0 = PrintFlagsDocument+    toEnum 1 = PrintFlagsMarkupAnnots+    toEnum 2 = PrintFlagsStampAnnotsOnly+    toEnum k = AnotherPrintFlags k++foreign import ccall "poppler_print_flags_get_type" c_poppler_print_flags_get_type :: +    IO GType++instance BoxedEnum PrintFlags where+    boxedEnumType _ = c_poppler_print_flags_get_type++instance IsGFlag PrintFlags++-- Flags Permissions++data Permissions = +      PermissionsOkToPrint+    | PermissionsOkToModify+    | PermissionsOkToCopy+    | PermissionsOkToAddNotes+    | PermissionsOkToFillForm+    | PermissionsOkToExtractContents+    | PermissionsOkToAssemble+    | PermissionsOkToPrintHighResolution+    | PermissionsFull+    | AnotherPermissions Int+    deriving (Show, Eq)++instance Enum Permissions where+    fromEnum PermissionsOkToPrint = 1+    fromEnum PermissionsOkToModify = 2+    fromEnum PermissionsOkToCopy = 4+    fromEnum PermissionsOkToAddNotes = 8+    fromEnum PermissionsOkToFillForm = 16+    fromEnum PermissionsOkToExtractContents = 32+    fromEnum PermissionsOkToAssemble = 64+    fromEnum PermissionsOkToPrintHighResolution = 128+    fromEnum PermissionsFull = 255+    fromEnum (AnotherPermissions k) = k++    toEnum 1 = PermissionsOkToPrint+    toEnum 2 = PermissionsOkToModify+    toEnum 4 = PermissionsOkToCopy+    toEnum 8 = PermissionsOkToAddNotes+    toEnum 16 = PermissionsOkToFillForm+    toEnum 32 = PermissionsOkToExtractContents+    toEnum 64 = PermissionsOkToAssemble+    toEnum 128 = PermissionsOkToPrintHighResolution+    toEnum 255 = PermissionsFull+    toEnum k = AnotherPermissions k++foreign import ccall "poppler_permissions_get_type" c_poppler_permissions_get_type :: +    IO GType++instance BoxedEnum Permissions where+    boxedEnumType _ = c_poppler_permissions_get_type++instance IsGFlag Permissions++-- Flags FindFlags++data FindFlags = +      FindFlagsDefault+    | FindFlagsCaseSensitive+    | FindFlagsBackwards+    | FindFlagsWholeWordsOnly+    | AnotherFindFlags Int+    deriving (Show, Eq)++instance Enum FindFlags where+    fromEnum FindFlagsDefault = 0+    fromEnum FindFlagsCaseSensitive = 1+    fromEnum FindFlagsBackwards = 2+    fromEnum FindFlagsWholeWordsOnly = 4+    fromEnum (AnotherFindFlags k) = k++    toEnum 0 = FindFlagsDefault+    toEnum 1 = FindFlagsCaseSensitive+    toEnum 2 = FindFlagsBackwards+    toEnum 4 = FindFlagsWholeWordsOnly+    toEnum k = AnotherFindFlags k++foreign import ccall "poppler_find_flags_get_type" c_poppler_find_flags_get_type :: +    IO GType++instance BoxedEnum FindFlags where+    boxedEnumType _ = c_poppler_find_flags_get_type++instance IsGFlag FindFlags++-- Flags AnnotFlag++data AnnotFlag = +      AnnotFlagUnknown+    | AnnotFlagInvisible+    | AnnotFlagHidden+    | AnnotFlagPrint+    | AnnotFlagNoZoom+    | AnnotFlagNoRotate+    | AnnotFlagNoView+    | AnnotFlagReadOnly+    | AnnotFlagLocked+    | AnnotFlagToggleNoView+    | AnnotFlagLockedContents+    | AnotherAnnotFlag Int+    deriving (Show, Eq)++instance Enum AnnotFlag where+    fromEnum AnnotFlagUnknown = 0+    fromEnum AnnotFlagInvisible = 1+    fromEnum AnnotFlagHidden = 2+    fromEnum AnnotFlagPrint = 4+    fromEnum AnnotFlagNoZoom = 8+    fromEnum AnnotFlagNoRotate = 16+    fromEnum AnnotFlagNoView = 32+    fromEnum AnnotFlagReadOnly = 64+    fromEnum AnnotFlagLocked = 128+    fromEnum AnnotFlagToggleNoView = 256+    fromEnum AnnotFlagLockedContents = 512+    fromEnum (AnotherAnnotFlag k) = k++    toEnum 0 = AnnotFlagUnknown+    toEnum 1 = AnnotFlagInvisible+    toEnum 2 = AnnotFlagHidden+    toEnum 4 = AnnotFlagPrint+    toEnum 8 = AnnotFlagNoZoom+    toEnum 16 = AnnotFlagNoRotate+    toEnum 32 = AnnotFlagNoView+    toEnum 64 = AnnotFlagReadOnly+    toEnum 128 = AnnotFlagLocked+    toEnum 256 = AnnotFlagToggleNoView+    toEnum 512 = AnnotFlagLockedContents+    toEnum k = AnotherAnnotFlag k++foreign import ccall "poppler_annot_flag_get_type" c_poppler_annot_flag_get_type :: +    IO GType++instance BoxedEnum AnnotFlag where+    boxedEnumType _ = c_poppler_annot_flag_get_type++instance IsGFlag AnnotFlag++
+ GI/Poppler/Functions.hs view
@@ -0,0 +1,132 @@++{- |+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.Functions+    ( ++ -- * Methods+-- ** dateParse+    dateParse                               ,+++-- ** errorQuark+    errorQuark                              ,+++-- ** getBackend+    getBackend                              ,+++-- ** getVersion+    getVersion                              ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Poppler.Types+import GI.Poppler.Callbacks++-- function poppler_get_version+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "poppler_get_version" poppler_get_version :: +    IO CString+++getVersion ::+    (MonadIO m) =>+    m T.Text+getVersion  = liftIO $ do+    result <- poppler_get_version+    checkUnexpectedReturnNULL "poppler_get_version" result+    result' <- cstringToText result+    return result'+++-- function poppler_get_backend+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Poppler" "Backend"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_get_backend" poppler_get_backend :: +    IO CUInt+++getBackend ::+    (MonadIO m) =>+    m Backend+getBackend  = liftIO $ do+    result <- poppler_get_backend+    let result' = (toEnum . fromIntegral) result+    return result'+++-- function poppler_error_quark+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "poppler_error_quark" poppler_error_quark :: +    IO Word32+++errorQuark ::+    (MonadIO m) =>+    m Word32+errorQuark  = liftIO $ do+    result <- poppler_error_quark+    return result+++-- function poppler_date_parse+-- Args : [Arg {argName = "date", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "timet", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "date", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "timet", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "poppler_date_parse" poppler_date_parse :: +    CString ->                              -- date : TBasicType TUTF8+    Int64 ->                                -- timet : TBasicType TInt64+    IO CInt+++dateParse ::+    (MonadIO m) =>+    T.Text ->                               -- date+    Int64 ->                                -- timet+    m Bool+dateParse date timet = liftIO $ do+    date' <- textToCString date+    result <- poppler_date_parse date' timet+    let result' = (/= 0) result+    freeMem date'+    return result'+++
+ GI/Poppler/Objects.hs view
@@ -0,0 +1,66 @@++{- |+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+    (     module GI.Poppler.Objects.Annot         ,+    module GI.Poppler.Objects.AnnotCircle   ,+    module GI.Poppler.Objects.AnnotFileAttachment,+    module GI.Poppler.Objects.AnnotFreeText ,+    module GI.Poppler.Objects.AnnotLine     ,+    module GI.Poppler.Objects.AnnotMarkup   ,+    module GI.Poppler.Objects.AnnotMovie    ,+    module GI.Poppler.Objects.AnnotScreen   ,+    module GI.Poppler.Objects.AnnotSquare   ,+    module GI.Poppler.Objects.AnnotText     ,+    module GI.Poppler.Objects.AnnotTextMarkup,+    module GI.Poppler.Objects.Attachment    ,+    module GI.Poppler.Objects.Document      ,+    module GI.Poppler.Objects.FontInfo      ,+    module GI.Poppler.Objects.FormField     ,+    module GI.Poppler.Objects.Layer         ,+    module GI.Poppler.Objects.Media         ,+    module GI.Poppler.Objects.Movie         ,+    module GI.Poppler.Objects.PSFile        ,+    module GI.Poppler.Objects.Page          ,+    module GI.Poppler.Objects.StructureElement,+++    ) where++import GI.Poppler.Objects.Annot+import GI.Poppler.Objects.AnnotCircle+import GI.Poppler.Objects.AnnotFileAttachment+import GI.Poppler.Objects.AnnotFreeText+import GI.Poppler.Objects.AnnotLine+import GI.Poppler.Objects.AnnotMarkup+import GI.Poppler.Objects.AnnotMovie+import GI.Poppler.Objects.AnnotScreen+import GI.Poppler.Objects.AnnotSquare+import GI.Poppler.Objects.AnnotText+import GI.Poppler.Objects.AnnotTextMarkup+import GI.Poppler.Objects.Attachment+import GI.Poppler.Objects.Document+import GI.Poppler.Objects.FontInfo+import GI.Poppler.Objects.FormField+import GI.Poppler.Objects.Layer+import GI.Poppler.Objects.Media+import GI.Poppler.Objects.Movie+import GI.Poppler.Objects.PSFile+import GI.Poppler.Objects.Page+import GI.Poppler.Objects.StructureElement++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Poppler.Types+import GI.Poppler.Callbacks++
+ GI/Poppler/Objects/Annot.hs view
@@ -0,0 +1,432 @@++{- |+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.Annot+    ( ++-- * Exported types+    Annot(..)                               ,+    AnnotK                                  ,+    toAnnot                                 ,+    noAnnot                                 ,+++ -- * Methods+-- ** annotGetAnnotType+    annotGetAnnotType                       ,+++-- ** annotGetColor+    annotGetColor                           ,+++-- ** annotGetContents+    annotGetContents                        ,+++-- ** annotGetFlags+    annotGetFlags                           ,+++-- ** annotGetModified+    annotGetModified                        ,+++-- ** annotGetName+    annotGetName                            ,+++-- ** annotGetPageIndex+    annotGetPageIndex                       ,+++-- ** annotGetRectangle+    annotGetRectangle                       ,+++-- ** annotSetColor+    annotSetColor                           ,+++-- ** annotSetContents+    annotSetContents                        ,+++-- ** annotSetFlags+    annotSetFlags                           ,+++-- ** annotSetRectangle+    annotSetRectangle                       ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Poppler.Types+import GI.Poppler.Callbacks+import qualified GI.GObject as GObject++newtype Annot = Annot (ForeignPtr Annot)+foreign import ccall "poppler_annot_get_type"+    c_poppler_annot_get_type :: IO GType++type instance ParentTypes Annot = AnnotParentTypes+type AnnotParentTypes = '[GObject.Object]++instance GObject Annot where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_poppler_annot_get_type+    ++class GObject o => AnnotK o+instance (GObject o, IsDescendantOf Annot o) => AnnotK o++toAnnot :: AnnotK o => o -> IO Annot+toAnnot = unsafeCastTo Annot++noAnnot :: Maybe Annot+noAnnot = Nothing++type instance AttributeList Annot = AnnotAttributeList+type AnnotAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList Annot = AnnotSignalList+type AnnotSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method Annot::get_annot_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Annot", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Annot", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "AnnotType"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_annot_get_annot_type" poppler_annot_get_annot_type :: +    Ptr Annot ->                            -- _obj : TInterface "Poppler" "Annot"+    IO CUInt+++annotGetAnnotType ::+    (MonadIO m, AnnotK a) =>+    a ->                                    -- _obj+    m AnnotType+annotGetAnnotType _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_annot_get_annot_type _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method Annot::get_color+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Annot", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Annot", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "Color"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_annot_get_color" poppler_annot_get_color :: +    Ptr Annot ->                            -- _obj : TInterface "Poppler" "Annot"+    IO (Ptr Color)+++annotGetColor ::+    (MonadIO m, AnnotK a) =>+    a ->                                    -- _obj+    m Color+annotGetColor _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_annot_get_color _obj'+    checkUnexpectedReturnNULL "poppler_annot_get_color" result+    result' <- (wrapBoxed Color) result+    touchManagedPtr _obj+    return result'++-- method Annot::get_contents+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Annot", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Annot", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "poppler_annot_get_contents" poppler_annot_get_contents :: +    Ptr Annot ->                            -- _obj : TInterface "Poppler" "Annot"+    IO CString+++annotGetContents ::+    (MonadIO m, AnnotK a) =>+    a ->                                    -- _obj+    m T.Text+annotGetContents _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_annot_get_contents _obj'+    checkUnexpectedReturnNULL "poppler_annot_get_contents" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method Annot::get_flags+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Annot", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Annot", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "AnnotFlag"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_annot_get_flags" poppler_annot_get_flags :: +    Ptr Annot ->                            -- _obj : TInterface "Poppler" "Annot"+    IO CUInt+++annotGetFlags ::+    (MonadIO m, AnnotK a) =>+    a ->                                    -- _obj+    m [AnnotFlag]+annotGetFlags _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_annot_get_flags _obj'+    let result' = wordToGFlags result+    touchManagedPtr _obj+    return result'++-- method Annot::get_modified+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Annot", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Annot", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "poppler_annot_get_modified" poppler_annot_get_modified :: +    Ptr Annot ->                            -- _obj : TInterface "Poppler" "Annot"+    IO CString+++annotGetModified ::+    (MonadIO m, AnnotK a) =>+    a ->                                    -- _obj+    m T.Text+annotGetModified _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_annot_get_modified _obj'+    checkUnexpectedReturnNULL "poppler_annot_get_modified" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method Annot::get_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Annot", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Annot", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "poppler_annot_get_name" poppler_annot_get_name :: +    Ptr Annot ->                            -- _obj : TInterface "Poppler" "Annot"+    IO CString+++annotGetName ::+    (MonadIO m, AnnotK a) =>+    a ->                                    -- _obj+    m T.Text+annotGetName _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_annot_get_name _obj'+    checkUnexpectedReturnNULL "poppler_annot_get_name" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method Annot::get_page_index+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Annot", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Annot", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "poppler_annot_get_page_index" poppler_annot_get_page_index :: +    Ptr Annot ->                            -- _obj : TInterface "Poppler" "Annot"+    IO Int32+++annotGetPageIndex ::+    (MonadIO m, AnnotK a) =>+    a ->                                    -- _obj+    m Int32+annotGetPageIndex _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_annot_get_page_index _obj'+    touchManagedPtr _obj+    return result++-- method Annot::get_rectangle+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Annot", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "poppler_rect", argType = TInterface "Poppler" "Rectangle", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Annot", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_annot_get_rectangle" poppler_annot_get_rectangle :: +    Ptr Annot ->                            -- _obj : TInterface "Poppler" "Annot"+    Ptr Rectangle ->                        -- poppler_rect : TInterface "Poppler" "Rectangle"+    IO ()+++annotGetRectangle ::+    (MonadIO m, AnnotK a) =>+    a ->                                    -- _obj+    m (Rectangle)+annotGetRectangle _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    poppler_rect <- callocBoxedBytes 32 :: IO (Ptr Rectangle)+    poppler_annot_get_rectangle _obj' poppler_rect+    poppler_rect' <- (wrapBoxed Rectangle) poppler_rect+    touchManagedPtr _obj+    return poppler_rect'++-- method Annot::set_color+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Annot", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "poppler_color", argType = TInterface "Poppler" "Color", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Annot", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "poppler_color", argType = TInterface "Poppler" "Color", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_annot_set_color" poppler_annot_set_color :: +    Ptr Annot ->                            -- _obj : TInterface "Poppler" "Annot"+    Ptr Color ->                            -- poppler_color : TInterface "Poppler" "Color"+    IO ()+++annotSetColor ::+    (MonadIO m, AnnotK a) =>+    a ->                                    -- _obj+    Maybe (Color) ->                        -- poppler_color+    m ()+annotSetColor _obj poppler_color = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybePoppler_color <- case poppler_color of+        Nothing -> return nullPtr+        Just jPoppler_color -> do+            let jPoppler_color' = unsafeManagedPtrGetPtr jPoppler_color+            return jPoppler_color'+    poppler_annot_set_color _obj' maybePoppler_color+    touchManagedPtr _obj+    whenJust poppler_color touchManagedPtr+    return ()++-- method Annot::set_contents+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Annot", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "contents", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Annot", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "contents", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_annot_set_contents" poppler_annot_set_contents :: +    Ptr Annot ->                            -- _obj : TInterface "Poppler" "Annot"+    CString ->                              -- contents : TBasicType TUTF8+    IO ()+++annotSetContents ::+    (MonadIO m, AnnotK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- contents+    m ()+annotSetContents _obj contents = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    contents' <- textToCString contents+    poppler_annot_set_contents _obj' contents'+    touchManagedPtr _obj+    freeMem contents'+    return ()++-- method Annot::set_flags+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Annot", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Poppler" "AnnotFlag", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Annot", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Poppler" "AnnotFlag", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_annot_set_flags" poppler_annot_set_flags :: +    Ptr Annot ->                            -- _obj : TInterface "Poppler" "Annot"+    CUInt ->                                -- flags : TInterface "Poppler" "AnnotFlag"+    IO ()+++annotSetFlags ::+    (MonadIO m, AnnotK a) =>+    a ->                                    -- _obj+    [AnnotFlag] ->                          -- flags+    m ()+annotSetFlags _obj flags = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let flags' = gflagsToWord flags+    poppler_annot_set_flags _obj' flags'+    touchManagedPtr _obj+    return ()++-- method Annot::set_rectangle+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Annot", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "poppler_rect", argType = TInterface "Poppler" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Annot", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "poppler_rect", argType = TInterface "Poppler" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_annot_set_rectangle" poppler_annot_set_rectangle :: +    Ptr Annot ->                            -- _obj : TInterface "Poppler" "Annot"+    Ptr Rectangle ->                        -- poppler_rect : TInterface "Poppler" "Rectangle"+    IO ()+++annotSetRectangle ::+    (MonadIO m, AnnotK a) =>+    a ->                                    -- _obj+    Rectangle ->                            -- poppler_rect+    m ()+annotSetRectangle _obj poppler_rect = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let poppler_rect' = unsafeManagedPtrGetPtr poppler_rect+    poppler_annot_set_rectangle _obj' poppler_rect'+    touchManagedPtr _obj+    touchManagedPtr poppler_rect+    return ()++
+ GI/Poppler/Objects/Annot.hs-boot view
@@ -0,0 +1,13 @@+module GI.Poppler.Objects.Annot where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype Annot = Annot (ForeignPtr Annot)+instance GObject Annot where+class GObject o => AnnotK o+instance (GObject o, IsDescendantOf Annot o) => AnnotK o
+ GI/Poppler/Objects/AnnotCircle.hs view
@@ -0,0 +1,161 @@++{- |+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.AnnotCircle+    ( ++-- * Exported types+    AnnotCircle(..)                         ,+    AnnotCircleK                            ,+    toAnnotCircle                           ,+    noAnnotCircle                           ,+++ -- * Methods+-- ** annotCircleGetInteriorColor+    annotCircleGetInteriorColor             ,+++-- ** annotCircleNew+    annotCircleNew                          ,+++-- ** annotCircleSetInteriorColor+    annotCircleSetInteriorColor             ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Poppler.Types+import GI.Poppler.Callbacks+import qualified GI.GObject as GObject++newtype AnnotCircle = AnnotCircle (ForeignPtr AnnotCircle)+foreign import ccall "poppler_annot_circle_get_type"+    c_poppler_annot_circle_get_type :: IO GType++type instance ParentTypes AnnotCircle = AnnotCircleParentTypes+type AnnotCircleParentTypes = '[AnnotMarkup, Annot, GObject.Object]++instance GObject AnnotCircle where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_poppler_annot_circle_get_type+    ++class GObject o => AnnotCircleK o+instance (GObject o, IsDescendantOf AnnotCircle o) => AnnotCircleK o++toAnnotCircle :: AnnotCircleK o => o -> IO AnnotCircle+toAnnotCircle = unsafeCastTo AnnotCircle++noAnnotCircle :: Maybe AnnotCircle+noAnnotCircle = Nothing++type instance AttributeList AnnotCircle = AnnotCircleAttributeList+type AnnotCircleAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList AnnotCircle = AnnotCircleSignalList+type AnnotCircleSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method AnnotCircle::new+-- method type : Constructor+-- Args : [Arg {argName = "doc", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "rect", argType = TInterface "Poppler" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "doc", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "rect", argType = TInterface "Poppler" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "AnnotCircle"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_annot_circle_new" poppler_annot_circle_new :: +    Ptr Document ->                         -- doc : TInterface "Poppler" "Document"+    Ptr Rectangle ->                        -- rect : TInterface "Poppler" "Rectangle"+    IO (Ptr AnnotCircle)+++annotCircleNew ::+    (MonadIO m, DocumentK a) =>+    a ->                                    -- doc+    Rectangle ->                            -- rect+    m AnnotCircle+annotCircleNew doc rect = liftIO $ do+    let doc' = unsafeManagedPtrCastPtr doc+    let rect' = unsafeManagedPtrGetPtr rect+    result <- poppler_annot_circle_new doc' rect'+    checkUnexpectedReturnNULL "poppler_annot_circle_new" result+    result' <- (wrapObject AnnotCircle) result+    touchManagedPtr doc+    touchManagedPtr rect+    return result'++-- method AnnotCircle::get_interior_color+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotCircle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotCircle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "Color"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_annot_circle_get_interior_color" poppler_annot_circle_get_interior_color :: +    Ptr AnnotCircle ->                      -- _obj : TInterface "Poppler" "AnnotCircle"+    IO (Ptr Color)+++annotCircleGetInteriorColor ::+    (MonadIO m, AnnotCircleK a) =>+    a ->                                    -- _obj+    m Color+annotCircleGetInteriorColor _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_annot_circle_get_interior_color _obj'+    checkUnexpectedReturnNULL "poppler_annot_circle_get_interior_color" result+    result' <- (wrapBoxed Color) result+    touchManagedPtr _obj+    return result'++-- method AnnotCircle::set_interior_color+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotCircle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "poppler_color", argType = TInterface "Poppler" "Color", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotCircle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "poppler_color", argType = TInterface "Poppler" "Color", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_annot_circle_set_interior_color" poppler_annot_circle_set_interior_color :: +    Ptr AnnotCircle ->                      -- _obj : TInterface "Poppler" "AnnotCircle"+    Ptr Color ->                            -- poppler_color : TInterface "Poppler" "Color"+    IO ()+++annotCircleSetInteriorColor ::+    (MonadIO m, AnnotCircleK a) =>+    a ->                                    -- _obj+    Maybe (Color) ->                        -- poppler_color+    m ()+annotCircleSetInteriorColor _obj poppler_color = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybePoppler_color <- case poppler_color of+        Nothing -> return nullPtr+        Just jPoppler_color -> do+            let jPoppler_color' = unsafeManagedPtrGetPtr jPoppler_color+            return jPoppler_color'+    poppler_annot_circle_set_interior_color _obj' maybePoppler_color+    touchManagedPtr _obj+    whenJust poppler_color touchManagedPtr+    return ()++
+ GI/Poppler/Objects/AnnotCircle.hs-boot view
@@ -0,0 +1,13 @@+module GI.Poppler.Objects.AnnotCircle where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype AnnotCircle = AnnotCircle (ForeignPtr AnnotCircle)+instance GObject AnnotCircle where+class GObject o => AnnotCircleK o+instance (GObject o, IsDescendantOf AnnotCircle o) => AnnotCircleK o
+ GI/Poppler/Objects/AnnotFileAttachment.hs view
@@ -0,0 +1,122 @@++{- |+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.AnnotFileAttachment+    ( ++-- * Exported types+    AnnotFileAttachment(..)                 ,+    AnnotFileAttachmentK                    ,+    toAnnotFileAttachment                   ,+    noAnnotFileAttachment                   ,+++ -- * Methods+-- ** annotFileAttachmentGetAttachment+    annotFileAttachmentGetAttachment        ,+++-- ** annotFileAttachmentGetName+    annotFileAttachmentGetName              ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Poppler.Types+import GI.Poppler.Callbacks+import qualified GI.GObject as GObject++newtype AnnotFileAttachment = AnnotFileAttachment (ForeignPtr AnnotFileAttachment)+foreign import ccall "poppler_annot_file_attachment_get_type"+    c_poppler_annot_file_attachment_get_type :: IO GType++type instance ParentTypes AnnotFileAttachment = AnnotFileAttachmentParentTypes+type AnnotFileAttachmentParentTypes = '[AnnotMarkup, Annot, GObject.Object]++instance GObject AnnotFileAttachment where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_poppler_annot_file_attachment_get_type+    ++class GObject o => AnnotFileAttachmentK o+instance (GObject o, IsDescendantOf AnnotFileAttachment o) => AnnotFileAttachmentK o++toAnnotFileAttachment :: AnnotFileAttachmentK o => o -> IO AnnotFileAttachment+toAnnotFileAttachment = unsafeCastTo AnnotFileAttachment++noAnnotFileAttachment :: Maybe AnnotFileAttachment+noAnnotFileAttachment = Nothing++type instance AttributeList AnnotFileAttachment = AnnotFileAttachmentAttributeList+type AnnotFileAttachmentAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList AnnotFileAttachment = AnnotFileAttachmentSignalList+type AnnotFileAttachmentSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method AnnotFileAttachment::get_attachment+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotFileAttachment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotFileAttachment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "Attachment"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_annot_file_attachment_get_attachment" poppler_annot_file_attachment_get_attachment :: +    Ptr AnnotFileAttachment ->              -- _obj : TInterface "Poppler" "AnnotFileAttachment"+    IO (Ptr Attachment)+++annotFileAttachmentGetAttachment ::+    (MonadIO m, AnnotFileAttachmentK a) =>+    a ->                                    -- _obj+    m Attachment+annotFileAttachmentGetAttachment _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_annot_file_attachment_get_attachment _obj'+    checkUnexpectedReturnNULL "poppler_annot_file_attachment_get_attachment" result+    result' <- (wrapObject Attachment) result+    touchManagedPtr _obj+    return result'++-- method AnnotFileAttachment::get_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotFileAttachment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotFileAttachment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "poppler_annot_file_attachment_get_name" poppler_annot_file_attachment_get_name :: +    Ptr AnnotFileAttachment ->              -- _obj : TInterface "Poppler" "AnnotFileAttachment"+    IO CString+++annotFileAttachmentGetName ::+    (MonadIO m, AnnotFileAttachmentK a) =>+    a ->                                    -- _obj+    m T.Text+annotFileAttachmentGetName _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_annot_file_attachment_get_name _obj'+    checkUnexpectedReturnNULL "poppler_annot_file_attachment_get_name" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++
+ GI/Poppler/Objects/AnnotFileAttachment.hs-boot view
@@ -0,0 +1,13 @@+module GI.Poppler.Objects.AnnotFileAttachment where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype AnnotFileAttachment = AnnotFileAttachment (ForeignPtr AnnotFileAttachment)+instance GObject AnnotFileAttachment where+class GObject o => AnnotFileAttachmentK o+instance (GObject o, IsDescendantOf AnnotFileAttachment o) => AnnotFileAttachmentK o
+ GI/Poppler/Objects/AnnotFreeText.hs view
@@ -0,0 +1,120 @@++{- |+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.AnnotFreeText+    ( ++-- * Exported types+    AnnotFreeText(..)                       ,+    AnnotFreeTextK                          ,+    toAnnotFreeText                         ,+    noAnnotFreeText                         ,+++ -- * Methods+-- ** annotFreeTextGetCalloutLine+    annotFreeTextGetCalloutLine             ,+++-- ** annotFreeTextGetQuadding+    annotFreeTextGetQuadding                ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Poppler.Types+import GI.Poppler.Callbacks+import qualified GI.GObject as GObject++newtype AnnotFreeText = AnnotFreeText (ForeignPtr AnnotFreeText)+foreign import ccall "poppler_annot_free_text_get_type"+    c_poppler_annot_free_text_get_type :: IO GType++type instance ParentTypes AnnotFreeText = AnnotFreeTextParentTypes+type AnnotFreeTextParentTypes = '[AnnotMarkup, Annot, GObject.Object]++instance GObject AnnotFreeText where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_poppler_annot_free_text_get_type+    ++class GObject o => AnnotFreeTextK o+instance (GObject o, IsDescendantOf AnnotFreeText o) => AnnotFreeTextK o++toAnnotFreeText :: AnnotFreeTextK o => o -> IO AnnotFreeText+toAnnotFreeText = unsafeCastTo AnnotFreeText++noAnnotFreeText :: Maybe AnnotFreeText+noAnnotFreeText = Nothing++type instance AttributeList AnnotFreeText = AnnotFreeTextAttributeList+type AnnotFreeTextAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList AnnotFreeText = AnnotFreeTextSignalList+type AnnotFreeTextSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method AnnotFreeText::get_callout_line+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotFreeText", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotFreeText", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "AnnotCalloutLine"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_annot_free_text_get_callout_line" poppler_annot_free_text_get_callout_line :: +    Ptr AnnotFreeText ->                    -- _obj : TInterface "Poppler" "AnnotFreeText"+    IO (Ptr AnnotCalloutLine)+++annotFreeTextGetCalloutLine ::+    (MonadIO m, AnnotFreeTextK a) =>+    a ->                                    -- _obj+    m AnnotCalloutLine+annotFreeTextGetCalloutLine _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_annot_free_text_get_callout_line _obj'+    checkUnexpectedReturnNULL "poppler_annot_free_text_get_callout_line" result+    result' <- (wrapBoxed AnnotCalloutLine) result+    touchManagedPtr _obj+    return result'++-- method AnnotFreeText::get_quadding+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotFreeText", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotFreeText", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "AnnotFreeTextQuadding"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_annot_free_text_get_quadding" poppler_annot_free_text_get_quadding :: +    Ptr AnnotFreeText ->                    -- _obj : TInterface "Poppler" "AnnotFreeText"+    IO CUInt+++annotFreeTextGetQuadding ::+    (MonadIO m, AnnotFreeTextK a) =>+    a ->                                    -- _obj+    m AnnotFreeTextQuadding+annotFreeTextGetQuadding _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_annot_free_text_get_quadding _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++
+ GI/Poppler/Objects/AnnotFreeText.hs-boot view
@@ -0,0 +1,13 @@+module GI.Poppler.Objects.AnnotFreeText where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype AnnotFreeText = AnnotFreeText (ForeignPtr AnnotFreeText)+instance GObject AnnotFreeText where+class GObject o => AnnotFreeTextK o+instance (GObject o, IsDescendantOf AnnotFreeText o) => AnnotFreeTextK o
+ GI/Poppler/Objects/AnnotLine.hs view
@@ -0,0 +1,139 @@++{- |+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.AnnotLine+    ( ++-- * Exported types+    AnnotLine(..)                           ,+    AnnotLineK                              ,+    toAnnotLine                             ,+    noAnnotLine                             ,+++ -- * Methods+-- ** annotLineNew+    annotLineNew                            ,+++-- ** annotLineSetVertices+    annotLineSetVertices                    ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Poppler.Types+import GI.Poppler.Callbacks+import qualified GI.GObject as GObject++newtype AnnotLine = AnnotLine (ForeignPtr AnnotLine)+foreign import ccall "poppler_annot_line_get_type"+    c_poppler_annot_line_get_type :: IO GType++type instance ParentTypes AnnotLine = AnnotLineParentTypes+type AnnotLineParentTypes = '[AnnotMarkup, Annot, GObject.Object]++instance GObject AnnotLine where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_poppler_annot_line_get_type+    ++class GObject o => AnnotLineK o+instance (GObject o, IsDescendantOf AnnotLine o) => AnnotLineK o++toAnnotLine :: AnnotLineK o => o -> IO AnnotLine+toAnnotLine = unsafeCastTo AnnotLine++noAnnotLine :: Maybe AnnotLine+noAnnotLine = Nothing++type instance AttributeList AnnotLine = AnnotLineAttributeList+type AnnotLineAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList AnnotLine = AnnotLineSignalList+type AnnotLineSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method AnnotLine::new+-- method type : Constructor+-- Args : [Arg {argName = "doc", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "rect", argType = TInterface "Poppler" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "start", argType = TInterface "Poppler" "Point", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "end", argType = TInterface "Poppler" "Point", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "doc", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "rect", argType = TInterface "Poppler" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "start", argType = TInterface "Poppler" "Point", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "end", argType = TInterface "Poppler" "Point", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "AnnotLine"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_annot_line_new" poppler_annot_line_new :: +    Ptr Document ->                         -- doc : TInterface "Poppler" "Document"+    Ptr Rectangle ->                        -- rect : TInterface "Poppler" "Rectangle"+    Ptr Point ->                            -- start : TInterface "Poppler" "Point"+    Ptr Point ->                            -- end : TInterface "Poppler" "Point"+    IO (Ptr AnnotLine)+++annotLineNew ::+    (MonadIO m, DocumentK a) =>+    a ->                                    -- doc+    Rectangle ->                            -- rect+    Point ->                                -- start+    Point ->                                -- end+    m AnnotLine+annotLineNew doc rect start end = liftIO $ do+    let doc' = unsafeManagedPtrCastPtr doc+    let rect' = unsafeManagedPtrGetPtr rect+    let start' = unsafeManagedPtrGetPtr start+    let end' = unsafeManagedPtrGetPtr end+    result <- poppler_annot_line_new doc' rect' start' end'+    checkUnexpectedReturnNULL "poppler_annot_line_new" result+    result' <- (wrapObject AnnotLine) result+    touchManagedPtr doc+    touchManagedPtr rect+    touchManagedPtr start+    touchManagedPtr end+    return result'++-- method AnnotLine::set_vertices+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotLine", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "start", argType = TInterface "Poppler" "Point", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "end", argType = TInterface "Poppler" "Point", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotLine", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "start", argType = TInterface "Poppler" "Point", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "end", argType = TInterface "Poppler" "Point", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_annot_line_set_vertices" poppler_annot_line_set_vertices :: +    Ptr AnnotLine ->                        -- _obj : TInterface "Poppler" "AnnotLine"+    Ptr Point ->                            -- start : TInterface "Poppler" "Point"+    Ptr Point ->                            -- end : TInterface "Poppler" "Point"+    IO ()+++annotLineSetVertices ::+    (MonadIO m, AnnotLineK a) =>+    a ->                                    -- _obj+    Point ->                                -- start+    Point ->                                -- end+    m ()+annotLineSetVertices _obj start end = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let start' = unsafeManagedPtrGetPtr start+    let end' = unsafeManagedPtrGetPtr end+    poppler_annot_line_set_vertices _obj' start' end'+    touchManagedPtr _obj+    touchManagedPtr start+    touchManagedPtr end+    return ()++
+ GI/Poppler/Objects/AnnotLine.hs-boot view
@@ -0,0 +1,13 @@+module GI.Poppler.Objects.AnnotLine where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype AnnotLine = AnnotLine (ForeignPtr AnnotLine)+instance GObject AnnotLine where+class GObject o => AnnotLineK o+instance (GObject o, IsDescendantOf AnnotLine o) => AnnotLineK o
+ GI/Poppler/Objects/AnnotMarkup.hs view
@@ -0,0 +1,461 @@++{- |+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(..)                         ,+    AnnotMarkupK                            ,+    toAnnotMarkup                           ,+    noAnnotMarkup                           ,+++ -- * Methods+-- ** annotMarkupGetDate+    annotMarkupGetDate                      ,+++-- ** annotMarkupGetExternalData+    annotMarkupGetExternalData              ,+++-- ** annotMarkupGetLabel+    annotMarkupGetLabel                     ,+++-- ** annotMarkupGetOpacity+    annotMarkupGetOpacity                   ,+++-- ** annotMarkupGetPopupIsOpen+    annotMarkupGetPopupIsOpen               ,+++-- ** annotMarkupGetPopupRectangle+    annotMarkupGetPopupRectangle            ,+++-- ** annotMarkupGetReplyTo+    annotMarkupGetReplyTo                   ,+++-- ** annotMarkupGetSubject+    annotMarkupGetSubject                   ,+++-- ** annotMarkupHasPopup+    annotMarkupHasPopup                     ,+++-- ** annotMarkupSetLabel+    annotMarkupSetLabel                     ,+++-- ** annotMarkupSetOpacity+    annotMarkupSetOpacity                   ,+++-- ** annotMarkupSetPopup+    annotMarkupSetPopup                     ,+++-- ** annotMarkupSetPopupIsOpen+    annotMarkupSetPopupIsOpen               ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Poppler.Types+import GI.Poppler.Callbacks+import qualified GI.GLib as GLib+import qualified GI.GObject as GObject++newtype AnnotMarkup = AnnotMarkup (ForeignPtr AnnotMarkup)+foreign import ccall "poppler_annot_markup_get_type"+    c_poppler_annot_markup_get_type :: IO GType++type instance ParentTypes AnnotMarkup = AnnotMarkupParentTypes+type AnnotMarkupParentTypes = '[Annot, GObject.Object]++instance GObject AnnotMarkup where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_poppler_annot_markup_get_type+    ++class GObject o => AnnotMarkupK o+instance (GObject o, IsDescendantOf AnnotMarkup o) => AnnotMarkupK o++toAnnotMarkup :: AnnotMarkupK o => o -> IO AnnotMarkup+toAnnotMarkup = unsafeCastTo AnnotMarkup++noAnnotMarkup :: Maybe AnnotMarkup+noAnnotMarkup = Nothing++type instance AttributeList AnnotMarkup = AnnotMarkupAttributeList+type AnnotMarkupAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList AnnotMarkup = AnnotMarkupSignalList+type AnnotMarkupSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method AnnotMarkup::get_date+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotMarkup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotMarkup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "GLib" "Date"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_annot_markup_get_date" poppler_annot_markup_get_date :: +    Ptr AnnotMarkup ->                      -- _obj : TInterface "Poppler" "AnnotMarkup"+    IO (Ptr GLib.Date)+++annotMarkupGetDate ::+    (MonadIO m, AnnotMarkupK a) =>+    a ->                                    -- _obj+    m GLib.Date+annotMarkupGetDate _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_annot_markup_get_date _obj'+    checkUnexpectedReturnNULL "poppler_annot_markup_get_date" result+    result' <- (wrapBoxed GLib.Date) result+    touchManagedPtr _obj+    return result'++-- method AnnotMarkup::get_external_data+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotMarkup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotMarkup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "AnnotExternalDataType"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_annot_markup_get_external_data" poppler_annot_markup_get_external_data :: +    Ptr AnnotMarkup ->                      -- _obj : TInterface "Poppler" "AnnotMarkup"+    IO CUInt+++annotMarkupGetExternalData ::+    (MonadIO m, AnnotMarkupK a) =>+    a ->                                    -- _obj+    m AnnotExternalDataType+annotMarkupGetExternalData _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_annot_markup_get_external_data _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method AnnotMarkup::get_label+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotMarkup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotMarkup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "poppler_annot_markup_get_label" poppler_annot_markup_get_label :: +    Ptr AnnotMarkup ->                      -- _obj : TInterface "Poppler" "AnnotMarkup"+    IO CString+++annotMarkupGetLabel ::+    (MonadIO m, AnnotMarkupK a) =>+    a ->                                    -- _obj+    m T.Text+annotMarkupGetLabel _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_annot_markup_get_label _obj'+    checkUnexpectedReturnNULL "poppler_annot_markup_get_label" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method AnnotMarkup::get_opacity+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotMarkup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotMarkup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TDouble+-- throws : False+-- Skip return : False++foreign import ccall "poppler_annot_markup_get_opacity" poppler_annot_markup_get_opacity :: +    Ptr AnnotMarkup ->                      -- _obj : TInterface "Poppler" "AnnotMarkup"+    IO CDouble+++annotMarkupGetOpacity ::+    (MonadIO m, AnnotMarkupK a) =>+    a ->                                    -- _obj+    m Double+annotMarkupGetOpacity _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_annot_markup_get_opacity _obj'+    let result' = realToFrac result+    touchManagedPtr _obj+    return result'++-- method AnnotMarkup::get_popup_is_open+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotMarkup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotMarkup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : 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 ->                      -- _obj : TInterface "Poppler" "AnnotMarkup"+    IO CInt+++annotMarkupGetPopupIsOpen ::+    (MonadIO m, AnnotMarkupK a) =>+    a ->                                    -- _obj+    m Bool+annotMarkupGetPopupIsOpen _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_annot_markup_get_popup_is_open _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method AnnotMarkup::get_popup_rectangle+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotMarkup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "poppler_rect", argType = TInterface "Poppler" "Rectangle", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotMarkup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "poppler_annot_markup_get_popup_rectangle" poppler_annot_markup_get_popup_rectangle :: +    Ptr AnnotMarkup ->                      -- _obj : TInterface "Poppler" "AnnotMarkup"+    Ptr Rectangle ->                        -- poppler_rect : TInterface "Poppler" "Rectangle"+    IO CInt+++annotMarkupGetPopupRectangle ::+    (MonadIO m, AnnotMarkupK a) =>+    a ->                                    -- _obj+    m (Bool,Rectangle)+annotMarkupGetPopupRectangle _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    poppler_rect <- callocBoxedBytes 32 :: IO (Ptr Rectangle)+    result <- poppler_annot_markup_get_popup_rectangle _obj' poppler_rect+    let result' = (/= 0) result+    poppler_rect' <- (wrapBoxed Rectangle) poppler_rect+    touchManagedPtr _obj+    return (result', poppler_rect')++-- method AnnotMarkup::get_reply_to+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotMarkup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotMarkup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "AnnotMarkupReplyType"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_annot_markup_get_reply_to" poppler_annot_markup_get_reply_to :: +    Ptr AnnotMarkup ->                      -- _obj : TInterface "Poppler" "AnnotMarkup"+    IO CUInt+++annotMarkupGetReplyTo ::+    (MonadIO m, AnnotMarkupK a) =>+    a ->                                    -- _obj+    m AnnotMarkupReplyType+annotMarkupGetReplyTo _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_annot_markup_get_reply_to _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method AnnotMarkup::get_subject+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotMarkup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotMarkup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "poppler_annot_markup_get_subject" poppler_annot_markup_get_subject :: +    Ptr AnnotMarkup ->                      -- _obj : TInterface "Poppler" "AnnotMarkup"+    IO CString+++annotMarkupGetSubject ::+    (MonadIO m, AnnotMarkupK a) =>+    a ->                                    -- _obj+    m T.Text+annotMarkupGetSubject _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_annot_markup_get_subject _obj'+    checkUnexpectedReturnNULL "poppler_annot_markup_get_subject" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method AnnotMarkup::has_popup+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotMarkup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotMarkup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "poppler_annot_markup_has_popup" poppler_annot_markup_has_popup :: +    Ptr AnnotMarkup ->                      -- _obj : TInterface "Poppler" "AnnotMarkup"+    IO CInt+++annotMarkupHasPopup ::+    (MonadIO m, AnnotMarkupK a) =>+    a ->                                    -- _obj+    m Bool+annotMarkupHasPopup _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_annot_markup_has_popup _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method AnnotMarkup::set_label+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotMarkup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotMarkup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_annot_markup_set_label" poppler_annot_markup_set_label :: +    Ptr AnnotMarkup ->                      -- _obj : TInterface "Poppler" "AnnotMarkup"+    CString ->                              -- label : TBasicType TUTF8+    IO ()+++annotMarkupSetLabel ::+    (MonadIO m, AnnotMarkupK a) =>+    a ->                                    -- _obj+    Maybe (T.Text) ->                       -- label+    m ()+annotMarkupSetLabel _obj label = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeLabel <- case label of+        Nothing -> return nullPtr+        Just jLabel -> do+            jLabel' <- textToCString jLabel+            return jLabel'+    poppler_annot_markup_set_label _obj' maybeLabel+    touchManagedPtr _obj+    freeMem maybeLabel+    return ()++-- method AnnotMarkup::set_opacity+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotMarkup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "opacity", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotMarkup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "opacity", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_annot_markup_set_opacity" poppler_annot_markup_set_opacity :: +    Ptr AnnotMarkup ->                      -- _obj : TInterface "Poppler" "AnnotMarkup"+    CDouble ->                              -- opacity : TBasicType TDouble+    IO ()+++annotMarkupSetOpacity ::+    (MonadIO m, AnnotMarkupK a) =>+    a ->                                    -- _obj+    Double ->                               -- opacity+    m ()+annotMarkupSetOpacity _obj opacity = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let opacity' = realToFrac opacity+    poppler_annot_markup_set_opacity _obj' opacity'+    touchManagedPtr _obj+    return ()++-- method AnnotMarkup::set_popup+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotMarkup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "popup_rect", argType = TInterface "Poppler" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotMarkup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "popup_rect", argType = TInterface "Poppler" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_annot_markup_set_popup" poppler_annot_markup_set_popup :: +    Ptr AnnotMarkup ->                      -- _obj : TInterface "Poppler" "AnnotMarkup"+    Ptr Rectangle ->                        -- popup_rect : TInterface "Poppler" "Rectangle"+    IO ()+++annotMarkupSetPopup ::+    (MonadIO m, AnnotMarkupK a) =>+    a ->                                    -- _obj+    Rectangle ->                            -- popup_rect+    m ()+annotMarkupSetPopup _obj popup_rect = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let popup_rect' = unsafeManagedPtrGetPtr popup_rect+    poppler_annot_markup_set_popup _obj' popup_rect'+    touchManagedPtr _obj+    touchManagedPtr popup_rect+    return ()++-- method AnnotMarkup::set_popup_is_open+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotMarkup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "is_open", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotMarkup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "is_open", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_annot_markup_set_popup_is_open" poppler_annot_markup_set_popup_is_open :: +    Ptr AnnotMarkup ->                      -- _obj : TInterface "Poppler" "AnnotMarkup"+    CInt ->                                 -- is_open : TBasicType TBoolean+    IO ()+++annotMarkupSetPopupIsOpen ::+    (MonadIO m, AnnotMarkupK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- is_open+    m ()+annotMarkupSetPopupIsOpen _obj is_open = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let is_open' = (fromIntegral . fromEnum) is_open+    poppler_annot_markup_set_popup_is_open _obj' is_open'+    touchManagedPtr _obj+    return ()++
+ GI/Poppler/Objects/AnnotMarkup.hs-boot view
@@ -0,0 +1,13 @@+module GI.Poppler.Objects.AnnotMarkup where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype AnnotMarkup = AnnotMarkup (ForeignPtr AnnotMarkup)+instance GObject AnnotMarkup where+class GObject o => AnnotMarkupK o+instance (GObject o, IsDescendantOf AnnotMarkup o) => AnnotMarkupK o
+ GI/Poppler/Objects/AnnotMovie.hs view
@@ -0,0 +1,122 @@++{- |+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.AnnotMovie+    ( ++-- * Exported types+    AnnotMovie(..)                          ,+    AnnotMovieK                             ,+    toAnnotMovie                            ,+    noAnnotMovie                            ,+++ -- * Methods+-- ** annotMovieGetMovie+    annotMovieGetMovie                      ,+++-- ** annotMovieGetTitle+    annotMovieGetTitle                      ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Poppler.Types+import GI.Poppler.Callbacks+import qualified GI.GObject as GObject++newtype AnnotMovie = AnnotMovie (ForeignPtr AnnotMovie)+foreign import ccall "poppler_annot_movie_get_type"+    c_poppler_annot_movie_get_type :: IO GType++type instance ParentTypes AnnotMovie = AnnotMovieParentTypes+type AnnotMovieParentTypes = '[Annot, GObject.Object]++instance GObject AnnotMovie where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_poppler_annot_movie_get_type+    ++class GObject o => AnnotMovieK o+instance (GObject o, IsDescendantOf AnnotMovie o) => AnnotMovieK o++toAnnotMovie :: AnnotMovieK o => o -> IO AnnotMovie+toAnnotMovie = unsafeCastTo AnnotMovie++noAnnotMovie :: Maybe AnnotMovie+noAnnotMovie = Nothing++type instance AttributeList AnnotMovie = AnnotMovieAttributeList+type AnnotMovieAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList AnnotMovie = AnnotMovieSignalList+type AnnotMovieSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method AnnotMovie::get_movie+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotMovie", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotMovie", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "Movie"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_annot_movie_get_movie" poppler_annot_movie_get_movie :: +    Ptr AnnotMovie ->                       -- _obj : TInterface "Poppler" "AnnotMovie"+    IO (Ptr Movie)+++annotMovieGetMovie ::+    (MonadIO m, AnnotMovieK a) =>+    a ->                                    -- _obj+    m Movie+annotMovieGetMovie _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_annot_movie_get_movie _obj'+    checkUnexpectedReturnNULL "poppler_annot_movie_get_movie" result+    result' <- (newObject Movie) result+    touchManagedPtr _obj+    return result'++-- method AnnotMovie::get_title+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotMovie", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotMovie", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "poppler_annot_movie_get_title" poppler_annot_movie_get_title :: +    Ptr AnnotMovie ->                       -- _obj : TInterface "Poppler" "AnnotMovie"+    IO CString+++annotMovieGetTitle ::+    (MonadIO m, AnnotMovieK a) =>+    a ->                                    -- _obj+    m T.Text+annotMovieGetTitle _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_annot_movie_get_title _obj'+    checkUnexpectedReturnNULL "poppler_annot_movie_get_title" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++
+ GI/Poppler/Objects/AnnotMovie.hs-boot view
@@ -0,0 +1,13 @@+module GI.Poppler.Objects.AnnotMovie where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype AnnotMovie = AnnotMovie (ForeignPtr AnnotMovie)+instance GObject AnnotMovie where+class GObject o => AnnotMovieK o+instance (GObject o, IsDescendantOf AnnotMovie o) => AnnotMovieK o
+ GI/Poppler/Objects/AnnotScreen.hs view
@@ -0,0 +1,91 @@++{- |+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.AnnotScreen+    ( ++-- * Exported types+    AnnotScreen(..)                         ,+    AnnotScreenK                            ,+    toAnnotScreen                           ,+    noAnnotScreen                           ,+++ -- * Methods+-- ** annotScreenGetAction+    annotScreenGetAction                    ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Poppler.Types+import GI.Poppler.Callbacks+import qualified GI.GObject as GObject++newtype AnnotScreen = AnnotScreen (ForeignPtr AnnotScreen)+foreign import ccall "poppler_annot_screen_get_type"+    c_poppler_annot_screen_get_type :: IO GType++type instance ParentTypes AnnotScreen = AnnotScreenParentTypes+type AnnotScreenParentTypes = '[Annot, GObject.Object]++instance GObject AnnotScreen where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_poppler_annot_screen_get_type+    ++class GObject o => AnnotScreenK o+instance (GObject o, IsDescendantOf AnnotScreen o) => AnnotScreenK o++toAnnotScreen :: AnnotScreenK o => o -> IO AnnotScreen+toAnnotScreen = unsafeCastTo AnnotScreen++noAnnotScreen :: Maybe AnnotScreen+noAnnotScreen = Nothing++type instance AttributeList AnnotScreen = AnnotScreenAttributeList+type AnnotScreenAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList AnnotScreen = AnnotScreenSignalList+type AnnotScreenSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method AnnotScreen::get_action+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotScreen", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotScreen", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "Action"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_annot_screen_get_action" poppler_annot_screen_get_action :: +    Ptr AnnotScreen ->                      -- _obj : TInterface "Poppler" "AnnotScreen"+    IO (Ptr Action)+++annotScreenGetAction ::+    (MonadIO m, AnnotScreenK a) =>+    a ->                                    -- _obj+    m Action+annotScreenGetAction _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_annot_screen_get_action _obj'+    checkUnexpectedReturnNULL "poppler_annot_screen_get_action" result+    result' <- (newBoxed Action) result+    touchManagedPtr _obj+    return result'++
+ GI/Poppler/Objects/AnnotScreen.hs-boot view
@@ -0,0 +1,13 @@+module GI.Poppler.Objects.AnnotScreen where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype AnnotScreen = AnnotScreen (ForeignPtr AnnotScreen)+instance GObject AnnotScreen where+class GObject o => AnnotScreenK o+instance (GObject o, IsDescendantOf AnnotScreen o) => AnnotScreenK o
+ GI/Poppler/Objects/AnnotSquare.hs view
@@ -0,0 +1,161 @@++{- |+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.AnnotSquare+    ( ++-- * Exported types+    AnnotSquare(..)                         ,+    AnnotSquareK                            ,+    toAnnotSquare                           ,+    noAnnotSquare                           ,+++ -- * Methods+-- ** annotSquareGetInteriorColor+    annotSquareGetInteriorColor             ,+++-- ** annotSquareNew+    annotSquareNew                          ,+++-- ** annotSquareSetInteriorColor+    annotSquareSetInteriorColor             ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Poppler.Types+import GI.Poppler.Callbacks+import qualified GI.GObject as GObject++newtype AnnotSquare = AnnotSquare (ForeignPtr AnnotSquare)+foreign import ccall "poppler_annot_square_get_type"+    c_poppler_annot_square_get_type :: IO GType++type instance ParentTypes AnnotSquare = AnnotSquareParentTypes+type AnnotSquareParentTypes = '[AnnotMarkup, Annot, GObject.Object]++instance GObject AnnotSquare where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_poppler_annot_square_get_type+    ++class GObject o => AnnotSquareK o+instance (GObject o, IsDescendantOf AnnotSquare o) => AnnotSquareK o++toAnnotSquare :: AnnotSquareK o => o -> IO AnnotSquare+toAnnotSquare = unsafeCastTo AnnotSquare++noAnnotSquare :: Maybe AnnotSquare+noAnnotSquare = Nothing++type instance AttributeList AnnotSquare = AnnotSquareAttributeList+type AnnotSquareAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList AnnotSquare = AnnotSquareSignalList+type AnnotSquareSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method AnnotSquare::new+-- method type : Constructor+-- Args : [Arg {argName = "doc", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "rect", argType = TInterface "Poppler" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "doc", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "rect", argType = TInterface "Poppler" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "AnnotSquare"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_annot_square_new" poppler_annot_square_new :: +    Ptr Document ->                         -- doc : TInterface "Poppler" "Document"+    Ptr Rectangle ->                        -- rect : TInterface "Poppler" "Rectangle"+    IO (Ptr AnnotSquare)+++annotSquareNew ::+    (MonadIO m, DocumentK a) =>+    a ->                                    -- doc+    Rectangle ->                            -- rect+    m AnnotSquare+annotSquareNew doc rect = liftIO $ do+    let doc' = unsafeManagedPtrCastPtr doc+    let rect' = unsafeManagedPtrGetPtr rect+    result <- poppler_annot_square_new doc' rect'+    checkUnexpectedReturnNULL "poppler_annot_square_new" result+    result' <- (wrapObject AnnotSquare) result+    touchManagedPtr doc+    touchManagedPtr rect+    return result'++-- method AnnotSquare::get_interior_color+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotSquare", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotSquare", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "Color"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_annot_square_get_interior_color" poppler_annot_square_get_interior_color :: +    Ptr AnnotSquare ->                      -- _obj : TInterface "Poppler" "AnnotSquare"+    IO (Ptr Color)+++annotSquareGetInteriorColor ::+    (MonadIO m, AnnotSquareK a) =>+    a ->                                    -- _obj+    m Color+annotSquareGetInteriorColor _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_annot_square_get_interior_color _obj'+    checkUnexpectedReturnNULL "poppler_annot_square_get_interior_color" result+    result' <- (wrapBoxed Color) result+    touchManagedPtr _obj+    return result'++-- method AnnotSquare::set_interior_color+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotSquare", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "poppler_color", argType = TInterface "Poppler" "Color", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotSquare", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "poppler_color", argType = TInterface "Poppler" "Color", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_annot_square_set_interior_color" poppler_annot_square_set_interior_color :: +    Ptr AnnotSquare ->                      -- _obj : TInterface "Poppler" "AnnotSquare"+    Ptr Color ->                            -- poppler_color : TInterface "Poppler" "Color"+    IO ()+++annotSquareSetInteriorColor ::+    (MonadIO m, AnnotSquareK a) =>+    a ->                                    -- _obj+    Maybe (Color) ->                        -- poppler_color+    m ()+annotSquareSetInteriorColor _obj poppler_color = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybePoppler_color <- case poppler_color of+        Nothing -> return nullPtr+        Just jPoppler_color -> do+            let jPoppler_color' = unsafeManagedPtrGetPtr jPoppler_color+            return jPoppler_color'+    poppler_annot_square_set_interior_color _obj' maybePoppler_color+    touchManagedPtr _obj+    whenJust poppler_color touchManagedPtr+    return ()++
+ GI/Poppler/Objects/AnnotSquare.hs-boot view
@@ -0,0 +1,13 @@+module GI.Poppler.Objects.AnnotSquare where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype AnnotSquare = AnnotSquare (ForeignPtr AnnotSquare)+instance GObject AnnotSquare where+class GObject o => AnnotSquareK o+instance (GObject o, IsDescendantOf AnnotSquare o) => AnnotSquareK o
+ GI/Poppler/Objects/AnnotText.hs view
@@ -0,0 +1,247 @@++{- |+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.AnnotText+    ( ++-- * Exported types+    AnnotText(..)                           ,+    AnnotTextK                              ,+    toAnnotText                             ,+    noAnnotText                             ,+++ -- * Methods+-- ** annotTextGetIcon+    annotTextGetIcon                        ,+++-- ** annotTextGetIsOpen+    annotTextGetIsOpen                      ,+++-- ** annotTextGetState+    annotTextGetState                       ,+++-- ** annotTextNew+    annotTextNew                            ,+++-- ** annotTextSetIcon+    annotTextSetIcon                        ,+++-- ** annotTextSetIsOpen+    annotTextSetIsOpen                      ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Poppler.Types+import GI.Poppler.Callbacks+import qualified GI.GObject as GObject++newtype AnnotText = AnnotText (ForeignPtr AnnotText)+foreign import ccall "poppler_annot_text_get_type"+    c_poppler_annot_text_get_type :: IO GType++type instance ParentTypes AnnotText = AnnotTextParentTypes+type AnnotTextParentTypes = '[AnnotMarkup, Annot, GObject.Object]++instance GObject AnnotText where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_poppler_annot_text_get_type+    ++class GObject o => AnnotTextK o+instance (GObject o, IsDescendantOf AnnotText o) => AnnotTextK o++toAnnotText :: AnnotTextK o => o -> IO AnnotText+toAnnotText = unsafeCastTo AnnotText++noAnnotText :: Maybe AnnotText+noAnnotText = Nothing++type instance AttributeList AnnotText = AnnotTextAttributeList+type AnnotTextAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList AnnotText = AnnotTextSignalList+type AnnotTextSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method AnnotText::new+-- method type : Constructor+-- Args : [Arg {argName = "doc", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "rect", argType = TInterface "Poppler" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "doc", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "rect", argType = TInterface "Poppler" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "AnnotText"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_annot_text_new" poppler_annot_text_new :: +    Ptr Document ->                         -- doc : TInterface "Poppler" "Document"+    Ptr Rectangle ->                        -- rect : TInterface "Poppler" "Rectangle"+    IO (Ptr AnnotText)+++annotTextNew ::+    (MonadIO m, DocumentK a) =>+    a ->                                    -- doc+    Rectangle ->                            -- rect+    m AnnotText+annotTextNew doc rect = liftIO $ do+    let doc' = unsafeManagedPtrCastPtr doc+    let rect' = unsafeManagedPtrGetPtr rect+    result <- poppler_annot_text_new doc' rect'+    checkUnexpectedReturnNULL "poppler_annot_text_new" result+    result' <- (wrapObject AnnotText) result+    touchManagedPtr doc+    touchManagedPtr rect+    return result'++-- method AnnotText::get_icon+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotText", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotText", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "poppler_annot_text_get_icon" poppler_annot_text_get_icon :: +    Ptr AnnotText ->                        -- _obj : TInterface "Poppler" "AnnotText"+    IO CString+++annotTextGetIcon ::+    (MonadIO m, AnnotTextK a) =>+    a ->                                    -- _obj+    m T.Text+annotTextGetIcon _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_annot_text_get_icon _obj'+    checkUnexpectedReturnNULL "poppler_annot_text_get_icon" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method AnnotText::get_is_open+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotText", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotText", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "poppler_annot_text_get_is_open" poppler_annot_text_get_is_open :: +    Ptr AnnotText ->                        -- _obj : TInterface "Poppler" "AnnotText"+    IO CInt+++annotTextGetIsOpen ::+    (MonadIO m, AnnotTextK a) =>+    a ->                                    -- _obj+    m Bool+annotTextGetIsOpen _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_annot_text_get_is_open _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method AnnotText::get_state+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotText", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotText", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "AnnotTextState"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_annot_text_get_state" poppler_annot_text_get_state :: +    Ptr AnnotText ->                        -- _obj : TInterface "Poppler" "AnnotText"+    IO CUInt+++annotTextGetState ::+    (MonadIO m, AnnotTextK a) =>+    a ->                                    -- _obj+    m AnnotTextState+annotTextGetState _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_annot_text_get_state _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method AnnotText::set_icon+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotText", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotText", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "icon", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_annot_text_set_icon" poppler_annot_text_set_icon :: +    Ptr AnnotText ->                        -- _obj : TInterface "Poppler" "AnnotText"+    CString ->                              -- icon : TBasicType TUTF8+    IO ()+++annotTextSetIcon ::+    (MonadIO m, AnnotTextK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- icon+    m ()+annotTextSetIcon _obj icon = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    icon' <- textToCString icon+    poppler_annot_text_set_icon _obj' icon'+    touchManagedPtr _obj+    freeMem icon'+    return ()++-- method AnnotText::set_is_open+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotText", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "is_open", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotText", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "is_open", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_annot_text_set_is_open" poppler_annot_text_set_is_open :: +    Ptr AnnotText ->                        -- _obj : TInterface "Poppler" "AnnotText"+    CInt ->                                 -- is_open : TBasicType TBoolean+    IO ()+++annotTextSetIsOpen ::+    (MonadIO m, AnnotTextK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- is_open+    m ()+annotTextSetIsOpen _obj is_open = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let is_open' = (fromIntegral . fromEnum) is_open+    poppler_annot_text_set_is_open _obj' is_open'+    touchManagedPtr _obj+    return ()++
+ GI/Poppler/Objects/AnnotText.hs-boot view
@@ -0,0 +1,13 @@+module GI.Poppler.Objects.AnnotText where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype AnnotText = AnnotText (ForeignPtr AnnotText)+instance GObject AnnotText where+class GObject o => AnnotTextK o+instance (GObject o, IsDescendantOf AnnotText o) => AnnotTextK o
+ GI/Poppler/Objects/AnnotTextMarkup.hs view
@@ -0,0 +1,287 @@++{- |+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.AnnotTextMarkup+    ( ++-- * Exported types+    AnnotTextMarkup(..)                     ,+    AnnotTextMarkupK                        ,+    toAnnotTextMarkup                       ,+    noAnnotTextMarkup                       ,+++ -- * Methods+-- ** annotTextMarkupGetQuadrilaterals+    annotTextMarkupGetQuadrilaterals        ,+++-- ** annotTextMarkupNewHighlight+    annotTextMarkupNewHighlight             ,+++-- ** annotTextMarkupNewSquiggly+    annotTextMarkupNewSquiggly              ,+++-- ** annotTextMarkupNewStrikeout+    annotTextMarkupNewStrikeout             ,+++-- ** annotTextMarkupNewUnderline+    annotTextMarkupNewUnderline             ,+++-- ** annotTextMarkupSetQuadrilaterals+    annotTextMarkupSetQuadrilaterals        ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Poppler.Types+import GI.Poppler.Callbacks+import qualified GI.GObject as GObject++newtype AnnotTextMarkup = AnnotTextMarkup (ForeignPtr AnnotTextMarkup)+foreign import ccall "poppler_annot_text_markup_get_type"+    c_poppler_annot_text_markup_get_type :: IO GType++type instance ParentTypes AnnotTextMarkup = AnnotTextMarkupParentTypes+type AnnotTextMarkupParentTypes = '[AnnotMarkup, Annot, GObject.Object]++instance GObject AnnotTextMarkup where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_poppler_annot_text_markup_get_type+    ++class GObject o => AnnotTextMarkupK o+instance (GObject o, IsDescendantOf AnnotTextMarkup o) => AnnotTextMarkupK o++toAnnotTextMarkup :: AnnotTextMarkupK o => o -> IO AnnotTextMarkup+toAnnotTextMarkup = unsafeCastTo AnnotTextMarkup++noAnnotTextMarkup :: Maybe AnnotTextMarkup+noAnnotTextMarkup = Nothing++type instance AttributeList AnnotTextMarkup = AnnotTextMarkupAttributeList+type AnnotTextMarkupAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList AnnotTextMarkup = AnnotTextMarkupSignalList+type AnnotTextMarkupSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method AnnotTextMarkup::new_highlight+-- method type : Constructor+-- Args : [Arg {argName = "doc", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "rect", argType = TInterface "Poppler" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "quadrilaterals", argType = TGArray (TInterface "Poppler" "Quadrilateral"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "doc", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "rect", argType = TInterface "Poppler" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "quadrilaterals", argType = TGArray (TInterface "Poppler" "Quadrilateral"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "AnnotTextMarkup"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_annot_text_markup_new_highlight" poppler_annot_text_markup_new_highlight :: +    Ptr Document ->                         -- doc : TInterface "Poppler" "Document"+    Ptr Rectangle ->                        -- rect : TInterface "Poppler" "Rectangle"+    Ptr (GArray (Ptr Quadrilateral)) ->     -- quadrilaterals : TGArray (TInterface "Poppler" "Quadrilateral")+    IO (Ptr AnnotTextMarkup)+++annotTextMarkupNewHighlight ::+    (MonadIO m, DocumentK a) =>+    a ->                                    -- doc+    Rectangle ->                            -- rect+    [Quadrilateral] ->                      -- quadrilaterals+    m AnnotTextMarkup+annotTextMarkupNewHighlight doc rect quadrilaterals = liftIO $ do+    let doc' = unsafeManagedPtrCastPtr doc+    let rect' = unsafeManagedPtrGetPtr rect+    let quadrilaterals' = map unsafeManagedPtrGetPtr quadrilaterals+    quadrilaterals'' <- packGArray quadrilaterals'+    result <- poppler_annot_text_markup_new_highlight doc' rect' quadrilaterals''+    checkUnexpectedReturnNULL "poppler_annot_text_markup_new_highlight" result+    result' <- (wrapObject AnnotTextMarkup) result+    touchManagedPtr doc+    touchManagedPtr rect+    mapM_ touchManagedPtr quadrilaterals+    unrefGArray quadrilaterals''+    return result'++-- method AnnotTextMarkup::new_squiggly+-- method type : Constructor+-- Args : [Arg {argName = "doc", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "rect", argType = TInterface "Poppler" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "quadrilaterals", argType = TGArray (TInterface "Poppler" "Quadrilateral"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "doc", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "rect", argType = TInterface "Poppler" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "quadrilaterals", argType = TGArray (TInterface "Poppler" "Quadrilateral"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "AnnotTextMarkup"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_annot_text_markup_new_squiggly" poppler_annot_text_markup_new_squiggly :: +    Ptr Document ->                         -- doc : TInterface "Poppler" "Document"+    Ptr Rectangle ->                        -- rect : TInterface "Poppler" "Rectangle"+    Ptr (GArray (Ptr Quadrilateral)) ->     -- quadrilaterals : TGArray (TInterface "Poppler" "Quadrilateral")+    IO (Ptr AnnotTextMarkup)+++annotTextMarkupNewSquiggly ::+    (MonadIO m, DocumentK a) =>+    a ->                                    -- doc+    Rectangle ->                            -- rect+    [Quadrilateral] ->                      -- quadrilaterals+    m AnnotTextMarkup+annotTextMarkupNewSquiggly doc rect quadrilaterals = liftIO $ do+    let doc' = unsafeManagedPtrCastPtr doc+    let rect' = unsafeManagedPtrGetPtr rect+    let quadrilaterals' = map unsafeManagedPtrGetPtr quadrilaterals+    quadrilaterals'' <- packGArray quadrilaterals'+    result <- poppler_annot_text_markup_new_squiggly doc' rect' quadrilaterals''+    checkUnexpectedReturnNULL "poppler_annot_text_markup_new_squiggly" result+    result' <- (wrapObject AnnotTextMarkup) result+    touchManagedPtr doc+    touchManagedPtr rect+    mapM_ touchManagedPtr quadrilaterals+    unrefGArray quadrilaterals''+    return result'++-- method AnnotTextMarkup::new_strikeout+-- method type : Constructor+-- Args : [Arg {argName = "doc", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "rect", argType = TInterface "Poppler" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "quadrilaterals", argType = TGArray (TInterface "Poppler" "Quadrilateral"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "doc", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "rect", argType = TInterface "Poppler" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "quadrilaterals", argType = TGArray (TInterface "Poppler" "Quadrilateral"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "AnnotTextMarkup"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_annot_text_markup_new_strikeout" poppler_annot_text_markup_new_strikeout :: +    Ptr Document ->                         -- doc : TInterface "Poppler" "Document"+    Ptr Rectangle ->                        -- rect : TInterface "Poppler" "Rectangle"+    Ptr (GArray (Ptr Quadrilateral)) ->     -- quadrilaterals : TGArray (TInterface "Poppler" "Quadrilateral")+    IO (Ptr AnnotTextMarkup)+++annotTextMarkupNewStrikeout ::+    (MonadIO m, DocumentK a) =>+    a ->                                    -- doc+    Rectangle ->                            -- rect+    [Quadrilateral] ->                      -- quadrilaterals+    m AnnotTextMarkup+annotTextMarkupNewStrikeout doc rect quadrilaterals = liftIO $ do+    let doc' = unsafeManagedPtrCastPtr doc+    let rect' = unsafeManagedPtrGetPtr rect+    let quadrilaterals' = map unsafeManagedPtrGetPtr quadrilaterals+    quadrilaterals'' <- packGArray quadrilaterals'+    result <- poppler_annot_text_markup_new_strikeout doc' rect' quadrilaterals''+    checkUnexpectedReturnNULL "poppler_annot_text_markup_new_strikeout" result+    result' <- (wrapObject AnnotTextMarkup) result+    touchManagedPtr doc+    touchManagedPtr rect+    mapM_ touchManagedPtr quadrilaterals+    unrefGArray quadrilaterals''+    return result'++-- method AnnotTextMarkup::new_underline+-- method type : Constructor+-- Args : [Arg {argName = "doc", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "rect", argType = TInterface "Poppler" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "quadrilaterals", argType = TGArray (TInterface "Poppler" "Quadrilateral"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "doc", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "rect", argType = TInterface "Poppler" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "quadrilaterals", argType = TGArray (TInterface "Poppler" "Quadrilateral"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "AnnotTextMarkup"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_annot_text_markup_new_underline" poppler_annot_text_markup_new_underline :: +    Ptr Document ->                         -- doc : TInterface "Poppler" "Document"+    Ptr Rectangle ->                        -- rect : TInterface "Poppler" "Rectangle"+    Ptr (GArray (Ptr Quadrilateral)) ->     -- quadrilaterals : TGArray (TInterface "Poppler" "Quadrilateral")+    IO (Ptr AnnotTextMarkup)+++annotTextMarkupNewUnderline ::+    (MonadIO m, DocumentK a) =>+    a ->                                    -- doc+    Rectangle ->                            -- rect+    [Quadrilateral] ->                      -- quadrilaterals+    m AnnotTextMarkup+annotTextMarkupNewUnderline doc rect quadrilaterals = liftIO $ do+    let doc' = unsafeManagedPtrCastPtr doc+    let rect' = unsafeManagedPtrGetPtr rect+    let quadrilaterals' = map unsafeManagedPtrGetPtr quadrilaterals+    quadrilaterals'' <- packGArray quadrilaterals'+    result <- poppler_annot_text_markup_new_underline doc' rect' quadrilaterals''+    checkUnexpectedReturnNULL "poppler_annot_text_markup_new_underline" result+    result' <- (wrapObject AnnotTextMarkup) result+    touchManagedPtr doc+    touchManagedPtr rect+    mapM_ touchManagedPtr quadrilaterals+    unrefGArray quadrilaterals''+    return result'++-- method AnnotTextMarkup::get_quadrilaterals+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotTextMarkup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotTextMarkup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGArray (TInterface "Poppler" "Quadrilateral")+-- throws : False+-- Skip return : False++foreign import ccall "poppler_annot_text_markup_get_quadrilaterals" poppler_annot_text_markup_get_quadrilaterals :: +    Ptr AnnotTextMarkup ->                  -- _obj : TInterface "Poppler" "AnnotTextMarkup"+    IO (Ptr (GArray (Ptr Quadrilateral)))+++annotTextMarkupGetQuadrilaterals ::+    (MonadIO m, AnnotTextMarkupK a) =>+    a ->                                    -- _obj+    m [Quadrilateral]+annotTextMarkupGetQuadrilaterals _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_annot_text_markup_get_quadrilaterals _obj'+    checkUnexpectedReturnNULL "poppler_annot_text_markup_get_quadrilaterals" result+    result' <- unpackGArray result+    result'' <- mapM (wrapBoxed Quadrilateral) result'+    unrefGArray result+    touchManagedPtr _obj+    return result''++-- method AnnotTextMarkup::set_quadrilaterals+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotTextMarkup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "quadrilaterals", argType = TGArray (TInterface "Poppler" "Quadrilateral"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotTextMarkup", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "quadrilaterals", argType = TGArray (TInterface "Poppler" "Quadrilateral"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_annot_text_markup_set_quadrilaterals" poppler_annot_text_markup_set_quadrilaterals :: +    Ptr AnnotTextMarkup ->                  -- _obj : TInterface "Poppler" "AnnotTextMarkup"+    Ptr (GArray (Ptr Quadrilateral)) ->     -- quadrilaterals : TGArray (TInterface "Poppler" "Quadrilateral")+    IO ()+++annotTextMarkupSetQuadrilaterals ::+    (MonadIO m, AnnotTextMarkupK a) =>+    a ->                                    -- _obj+    [Quadrilateral] ->                      -- quadrilaterals+    m ()+annotTextMarkupSetQuadrilaterals _obj quadrilaterals = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let quadrilaterals' = map unsafeManagedPtrGetPtr quadrilaterals+    quadrilaterals'' <- packGArray quadrilaterals'+    poppler_annot_text_markup_set_quadrilaterals _obj' quadrilaterals''+    touchManagedPtr _obj+    mapM_ touchManagedPtr quadrilaterals+    unrefGArray quadrilaterals''+    return ()++
+ GI/Poppler/Objects/AnnotTextMarkup.hs-boot view
@@ -0,0 +1,13 @@+module GI.Poppler.Objects.AnnotTextMarkup where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype AnnotTextMarkup = AnnotTextMarkup (ForeignPtr AnnotTextMarkup)+instance GObject AnnotTextMarkup where+class GObject o => AnnotTextMarkupK o+instance (GObject o, IsDescendantOf AnnotTextMarkup o) => AnnotTextMarkupK o
+ GI/Poppler/Objects/Attachment.hs view
@@ -0,0 +1,138 @@++{- |+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.Attachment+    ( ++-- * Exported types+    Attachment(..)                          ,+    AttachmentK                             ,+    toAttachment                            ,+    noAttachment                            ,+++ -- * Methods+-- ** attachmentSave+    attachmentSave                          ,+++-- ** attachmentSaveToCallback+    attachmentSaveToCallback                ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Poppler.Types+import GI.Poppler.Callbacks+import qualified GI.GObject as GObject++newtype Attachment = Attachment (ForeignPtr Attachment)+foreign import ccall "poppler_attachment_get_type"+    c_poppler_attachment_get_type :: IO GType++type instance ParentTypes Attachment = AttachmentParentTypes+type AttachmentParentTypes = '[GObject.Object]++instance GObject Attachment where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_poppler_attachment_get_type+    ++class GObject o => AttachmentK o+instance (GObject o, IsDescendantOf Attachment o) => AttachmentK o++toAttachment :: AttachmentK o => o -> IO Attachment+toAttachment = unsafeCastTo Attachment++noAttachment :: Maybe Attachment+noAttachment = Nothing++type instance AttributeList Attachment = AttachmentAttributeList+type AttachmentAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList Attachment = AttachmentSignalList+type AttachmentSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method Attachment::save+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Attachment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "filename", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Attachment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "filename", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "poppler_attachment_save" poppler_attachment_save :: +    Ptr Attachment ->                       -- _obj : TInterface "Poppler" "Attachment"+    CString ->                              -- filename : TBasicType TUTF8+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++attachmentSave ::+    (MonadIO m, AttachmentK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- filename+    m ()+attachmentSave _obj filename = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    filename' <- textToCString filename+    onException (do+        _ <- propagateGError $ poppler_attachment_save _obj' filename'+        touchManagedPtr _obj+        freeMem filename'+        return ()+     ) (do+        freeMem filename'+     )++-- method Attachment::save_to_callback+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Attachment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "save_func", argType = TInterface "Poppler" "AttachmentSaveFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Attachment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "save_func", argType = TInterface "Poppler" "AttachmentSaveFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "poppler_attachment_save_to_callback" poppler_attachment_save_to_callback :: +    Ptr Attachment ->                       -- _obj : TInterface "Poppler" "Attachment"+    FunPtr AttachmentSaveFuncC ->           -- save_func : TInterface "Poppler" "AttachmentSaveFunc"+    Ptr () ->                               -- user_data : TBasicType TVoid+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++attachmentSaveToCallback ::+    (MonadIO m, AttachmentK a) =>+    a ->                                    -- _obj+    AttachmentSaveFunc ->                   -- save_func+    m ()+attachmentSaveToCallback _obj save_func = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    save_func' <- mkAttachmentSaveFunc (attachmentSaveFuncWrapper Nothing save_func)+    let user_data = nullPtr+    onException (do+        _ <- propagateGError $ poppler_attachment_save_to_callback _obj' save_func' user_data+        safeFreeFunPtr $ castFunPtrToPtr save_func'+        touchManagedPtr _obj+        return ()+     ) (do+        safeFreeFunPtr $ castFunPtrToPtr save_func'+        return ()+     )++
+ GI/Poppler/Objects/Attachment.hs-boot view
@@ -0,0 +1,13 @@+module GI.Poppler.Objects.Attachment where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype Attachment = Attachment (ForeignPtr Attachment)+instance GObject Attachment where+class GObject o => AttachmentK o+instance (GObject o, IsDescendantOf Attachment o) => AttachmentK o
+ GI/Poppler/Objects/Document.hs view
@@ -0,0 +1,1470 @@++{- |+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.Document+    ( ++-- * Exported types+    Document(..)                            ,+    DocumentK                               ,+    toDocument                              ,+    noDocument                              ,+++ -- * Methods+-- ** documentFindDest+    documentFindDest                        ,+++-- ** documentGetAttachments+    documentGetAttachments                  ,+++-- ** documentGetAuthor+    documentGetAuthor                       ,+++-- ** documentGetCreationDate+    documentGetCreationDate                 ,+++-- ** documentGetCreator+    documentGetCreator                      ,+++-- ** documentGetFormField+    documentGetFormField                    ,+++-- ** documentGetId+    documentGetId                           ,+++-- ** documentGetKeywords+    documentGetKeywords                     ,+++-- ** documentGetMetadata+    documentGetMetadata                     ,+++-- ** documentGetModificationDate+    documentGetModificationDate             ,+++-- ** documentGetNAttachments+    documentGetNAttachments                 ,+++-- ** documentGetNPages+    documentGetNPages                       ,+++-- ** documentGetPage+    documentGetPage                         ,+++-- ** documentGetPageByLabel+    documentGetPageByLabel                  ,+++-- ** documentGetPageLayout+    documentGetPageLayout                   ,+++-- ** documentGetPageMode+    documentGetPageMode                     ,+++-- ** documentGetPdfVersion+    documentGetPdfVersion                   ,+++-- ** documentGetPdfVersionString+    documentGetPdfVersionString             ,+++-- ** documentGetPermissions+    documentGetPermissions                  ,+++-- ** documentGetProducer+    documentGetProducer                     ,+++-- ** documentGetSubject+    documentGetSubject                      ,+++-- ** documentGetTitle+    documentGetTitle                        ,+++-- ** documentHasAttachments+    documentHasAttachments                  ,+++-- ** documentIsLinearized+    documentIsLinearized                    ,+++-- ** documentNewFromData+    documentNewFromData                     ,+++-- ** documentNewFromFile+    documentNewFromFile                     ,+++-- ** documentNewFromGfile+    documentNewFromGfile                    ,+++-- ** documentNewFromStream+    documentNewFromStream                   ,+++-- ** documentSave+    documentSave                            ,+++-- ** documentSaveACopy+    documentSaveACopy                       ,+++++ -- * Properties+-- ** Author+    DocumentAuthorPropertyInfo              ,+    getDocumentAuthor                       ,+++-- ** CreationDate+    DocumentCreationDatePropertyInfo        ,+    getDocumentCreationDate                 ,+++-- ** Creator+    DocumentCreatorPropertyInfo             ,+    getDocumentCreator                      ,+++-- ** Format+    DocumentFormatPropertyInfo              ,+    getDocumentFormat                       ,+++-- ** FormatMajor+    DocumentFormatMajorPropertyInfo         ,+    getDocumentFormatMajor                  ,+++-- ** FormatMinor+    DocumentFormatMinorPropertyInfo         ,+    getDocumentFormatMinor                  ,+++-- ** Keywords+    DocumentKeywordsPropertyInfo            ,+    getDocumentKeywords                     ,+++-- ** Linearized+    DocumentLinearizedPropertyInfo          ,+    getDocumentLinearized                   ,+++-- ** Metadata+    DocumentMetadataPropertyInfo            ,+    getDocumentMetadata                     ,+++-- ** ModDate+    DocumentModDatePropertyInfo             ,+    getDocumentModDate                      ,+++-- ** PageLayout+    DocumentPageLayoutPropertyInfo          ,+    getDocumentPageLayout                   ,+++-- ** PageMode+    DocumentPageModePropertyInfo            ,+    getDocumentPageMode                     ,+++-- ** Permissions+    DocumentPermissionsPropertyInfo         ,+    getDocumentPermissions                  ,+++-- ** Producer+    DocumentProducerPropertyInfo            ,+    getDocumentProducer                     ,+++-- ** Subject+    DocumentSubjectPropertyInfo             ,+    getDocumentSubject                      ,+++-- ** Title+    DocumentTitlePropertyInfo               ,+    getDocumentTitle                        ,+++-- ** ViewerPreferences+    DocumentViewerPreferencesPropertyInfo   ,+    getDocumentViewerPreferences            ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Poppler.Types+import GI.Poppler.Callbacks+import qualified GI.GObject as GObject+import qualified GI.Gio as Gio++newtype Document = Document (ForeignPtr Document)+foreign import ccall "poppler_document_get_type"+    c_poppler_document_get_type :: IO GType++type instance ParentTypes Document = DocumentParentTypes+type DocumentParentTypes = '[GObject.Object]++instance GObject Document where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_poppler_document_get_type+    ++class GObject o => DocumentK o+instance (GObject o, IsDescendantOf Document o) => DocumentK o++toDocument :: DocumentK o => o -> IO Document+toDocument = unsafeCastTo Document++noDocument :: Maybe Document+noDocument = Nothing++-- VVV Prop "author"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable]++getDocumentAuthor :: (MonadIO m, DocumentK o) => o -> m T.Text+getDocumentAuthor obj = liftIO $ getObjectPropertyString obj "author"++data DocumentAuthorPropertyInfo+instance AttrInfo DocumentAuthorPropertyInfo where+    type AttrAllowedOps DocumentAuthorPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint DocumentAuthorPropertyInfo = (~) ()+    type AttrBaseTypeConstraint DocumentAuthorPropertyInfo = DocumentK+    type AttrGetType DocumentAuthorPropertyInfo = T.Text+    type AttrLabel DocumentAuthorPropertyInfo = "Document::author"+    attrGet _ = getDocumentAuthor+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "creation-date"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable]++getDocumentCreationDate :: (MonadIO m, DocumentK o) => o -> m Int32+getDocumentCreationDate obj = liftIO $ getObjectPropertyCInt obj "creation-date"++data DocumentCreationDatePropertyInfo+instance AttrInfo DocumentCreationDatePropertyInfo where+    type AttrAllowedOps DocumentCreationDatePropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint DocumentCreationDatePropertyInfo = (~) ()+    type AttrBaseTypeConstraint DocumentCreationDatePropertyInfo = DocumentK+    type AttrGetType DocumentCreationDatePropertyInfo = Int32+    type AttrLabel DocumentCreationDatePropertyInfo = "Document::creation-date"+    attrGet _ = getDocumentCreationDate+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "creator"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable]++getDocumentCreator :: (MonadIO m, DocumentK o) => o -> m T.Text+getDocumentCreator obj = liftIO $ getObjectPropertyString obj "creator"++data DocumentCreatorPropertyInfo+instance AttrInfo DocumentCreatorPropertyInfo where+    type AttrAllowedOps DocumentCreatorPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint DocumentCreatorPropertyInfo = (~) ()+    type AttrBaseTypeConstraint DocumentCreatorPropertyInfo = DocumentK+    type AttrGetType DocumentCreatorPropertyInfo = T.Text+    type AttrLabel DocumentCreatorPropertyInfo = "Document::creator"+    attrGet _ = getDocumentCreator+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "format"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable]++getDocumentFormat :: (MonadIO m, DocumentK o) => o -> m T.Text+getDocumentFormat obj = liftIO $ getObjectPropertyString obj "format"++data DocumentFormatPropertyInfo+instance AttrInfo DocumentFormatPropertyInfo where+    type AttrAllowedOps DocumentFormatPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint DocumentFormatPropertyInfo = (~) ()+    type AttrBaseTypeConstraint DocumentFormatPropertyInfo = DocumentK+    type AttrGetType DocumentFormatPropertyInfo = T.Text+    type AttrLabel DocumentFormatPropertyInfo = "Document::format"+    attrGet _ = getDocumentFormat+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "format-major"+   -- Type: TBasicType TUInt32+   -- Flags: [PropertyReadable]++getDocumentFormatMajor :: (MonadIO m, DocumentK o) => o -> m Word32+getDocumentFormatMajor obj = liftIO $ getObjectPropertyCUInt obj "format-major"++data DocumentFormatMajorPropertyInfo+instance AttrInfo DocumentFormatMajorPropertyInfo where+    type AttrAllowedOps DocumentFormatMajorPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint DocumentFormatMajorPropertyInfo = (~) ()+    type AttrBaseTypeConstraint DocumentFormatMajorPropertyInfo = DocumentK+    type AttrGetType DocumentFormatMajorPropertyInfo = Word32+    type AttrLabel DocumentFormatMajorPropertyInfo = "Document::format-major"+    attrGet _ = getDocumentFormatMajor+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "format-minor"+   -- Type: TBasicType TUInt32+   -- Flags: [PropertyReadable]++getDocumentFormatMinor :: (MonadIO m, DocumentK o) => o -> m Word32+getDocumentFormatMinor obj = liftIO $ getObjectPropertyCUInt obj "format-minor"++data DocumentFormatMinorPropertyInfo+instance AttrInfo DocumentFormatMinorPropertyInfo where+    type AttrAllowedOps DocumentFormatMinorPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint DocumentFormatMinorPropertyInfo = (~) ()+    type AttrBaseTypeConstraint DocumentFormatMinorPropertyInfo = DocumentK+    type AttrGetType DocumentFormatMinorPropertyInfo = Word32+    type AttrLabel DocumentFormatMinorPropertyInfo = "Document::format-minor"+    attrGet _ = getDocumentFormatMinor+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "keywords"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable]++getDocumentKeywords :: (MonadIO m, DocumentK o) => o -> m T.Text+getDocumentKeywords obj = liftIO $ getObjectPropertyString obj "keywords"++data DocumentKeywordsPropertyInfo+instance AttrInfo DocumentKeywordsPropertyInfo where+    type AttrAllowedOps DocumentKeywordsPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint DocumentKeywordsPropertyInfo = (~) ()+    type AttrBaseTypeConstraint DocumentKeywordsPropertyInfo = DocumentK+    type AttrGetType DocumentKeywordsPropertyInfo = T.Text+    type AttrLabel DocumentKeywordsPropertyInfo = "Document::keywords"+    attrGet _ = getDocumentKeywords+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "linearized"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable]++getDocumentLinearized :: (MonadIO m, DocumentK o) => o -> m Bool+getDocumentLinearized obj = liftIO $ getObjectPropertyBool obj "linearized"++data DocumentLinearizedPropertyInfo+instance AttrInfo DocumentLinearizedPropertyInfo where+    type AttrAllowedOps DocumentLinearizedPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint DocumentLinearizedPropertyInfo = (~) ()+    type AttrBaseTypeConstraint DocumentLinearizedPropertyInfo = DocumentK+    type AttrGetType DocumentLinearizedPropertyInfo = Bool+    type AttrLabel DocumentLinearizedPropertyInfo = "Document::linearized"+    attrGet _ = getDocumentLinearized+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "metadata"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable]++getDocumentMetadata :: (MonadIO m, DocumentK o) => o -> m T.Text+getDocumentMetadata obj = liftIO $ getObjectPropertyString obj "metadata"++data DocumentMetadataPropertyInfo+instance AttrInfo DocumentMetadataPropertyInfo where+    type AttrAllowedOps DocumentMetadataPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint DocumentMetadataPropertyInfo = (~) ()+    type AttrBaseTypeConstraint DocumentMetadataPropertyInfo = DocumentK+    type AttrGetType DocumentMetadataPropertyInfo = T.Text+    type AttrLabel DocumentMetadataPropertyInfo = "Document::metadata"+    attrGet _ = getDocumentMetadata+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "mod-date"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable]++getDocumentModDate :: (MonadIO m, DocumentK o) => o -> m Int32+getDocumentModDate obj = liftIO $ getObjectPropertyCInt obj "mod-date"++data DocumentModDatePropertyInfo+instance AttrInfo DocumentModDatePropertyInfo where+    type AttrAllowedOps DocumentModDatePropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint DocumentModDatePropertyInfo = (~) ()+    type AttrBaseTypeConstraint DocumentModDatePropertyInfo = DocumentK+    type AttrGetType DocumentModDatePropertyInfo = Int32+    type AttrLabel DocumentModDatePropertyInfo = "Document::mod-date"+    attrGet _ = getDocumentModDate+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "page-layout"+   -- Type: TInterface "Poppler" "PageLayout"+   -- Flags: [PropertyReadable]++getDocumentPageLayout :: (MonadIO m, DocumentK o) => o -> m PageLayout+getDocumentPageLayout obj = liftIO $ getObjectPropertyEnum obj "page-layout"++data DocumentPageLayoutPropertyInfo+instance AttrInfo DocumentPageLayoutPropertyInfo where+    type AttrAllowedOps DocumentPageLayoutPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint DocumentPageLayoutPropertyInfo = (~) ()+    type AttrBaseTypeConstraint DocumentPageLayoutPropertyInfo = DocumentK+    type AttrGetType DocumentPageLayoutPropertyInfo = PageLayout+    type AttrLabel DocumentPageLayoutPropertyInfo = "Document::page-layout"+    attrGet _ = getDocumentPageLayout+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "page-mode"+   -- Type: TInterface "Poppler" "PageMode"+   -- Flags: [PropertyReadable]++getDocumentPageMode :: (MonadIO m, DocumentK o) => o -> m PageMode+getDocumentPageMode obj = liftIO $ getObjectPropertyEnum obj "page-mode"++data DocumentPageModePropertyInfo+instance AttrInfo DocumentPageModePropertyInfo where+    type AttrAllowedOps DocumentPageModePropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint DocumentPageModePropertyInfo = (~) ()+    type AttrBaseTypeConstraint DocumentPageModePropertyInfo = DocumentK+    type AttrGetType DocumentPageModePropertyInfo = PageMode+    type AttrLabel DocumentPageModePropertyInfo = "Document::page-mode"+    attrGet _ = getDocumentPageMode+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "permissions"+   -- Type: TInterface "Poppler" "Permissions"+   -- Flags: [PropertyReadable]++getDocumentPermissions :: (MonadIO m, DocumentK o) => o -> m [Permissions]+getDocumentPermissions obj = liftIO $ getObjectPropertyFlags obj "permissions"++data DocumentPermissionsPropertyInfo+instance AttrInfo DocumentPermissionsPropertyInfo where+    type AttrAllowedOps DocumentPermissionsPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint DocumentPermissionsPropertyInfo = (~) ()+    type AttrBaseTypeConstraint DocumentPermissionsPropertyInfo = DocumentK+    type AttrGetType DocumentPermissionsPropertyInfo = [Permissions]+    type AttrLabel DocumentPermissionsPropertyInfo = "Document::permissions"+    attrGet _ = getDocumentPermissions+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "producer"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable]++getDocumentProducer :: (MonadIO m, DocumentK o) => o -> m T.Text+getDocumentProducer obj = liftIO $ getObjectPropertyString obj "producer"++data DocumentProducerPropertyInfo+instance AttrInfo DocumentProducerPropertyInfo where+    type AttrAllowedOps DocumentProducerPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint DocumentProducerPropertyInfo = (~) ()+    type AttrBaseTypeConstraint DocumentProducerPropertyInfo = DocumentK+    type AttrGetType DocumentProducerPropertyInfo = T.Text+    type AttrLabel DocumentProducerPropertyInfo = "Document::producer"+    attrGet _ = getDocumentProducer+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "subject"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable]++getDocumentSubject :: (MonadIO m, DocumentK o) => o -> m T.Text+getDocumentSubject obj = liftIO $ getObjectPropertyString obj "subject"++data DocumentSubjectPropertyInfo+instance AttrInfo DocumentSubjectPropertyInfo where+    type AttrAllowedOps DocumentSubjectPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint DocumentSubjectPropertyInfo = (~) ()+    type AttrBaseTypeConstraint DocumentSubjectPropertyInfo = DocumentK+    type AttrGetType DocumentSubjectPropertyInfo = T.Text+    type AttrLabel DocumentSubjectPropertyInfo = "Document::subject"+    attrGet _ = getDocumentSubject+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "title"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable]++getDocumentTitle :: (MonadIO m, DocumentK o) => o -> m T.Text+getDocumentTitle obj = liftIO $ getObjectPropertyString obj "title"++data DocumentTitlePropertyInfo+instance AttrInfo DocumentTitlePropertyInfo where+    type AttrAllowedOps DocumentTitlePropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint DocumentTitlePropertyInfo = (~) ()+    type AttrBaseTypeConstraint DocumentTitlePropertyInfo = DocumentK+    type AttrGetType DocumentTitlePropertyInfo = T.Text+    type AttrLabel DocumentTitlePropertyInfo = "Document::title"+    attrGet _ = getDocumentTitle+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "viewer-preferences"+   -- Type: TInterface "Poppler" "ViewerPreferences"+   -- Flags: [PropertyReadable]++getDocumentViewerPreferences :: (MonadIO m, DocumentK o) => o -> m [ViewerPreferences]+getDocumentViewerPreferences obj = liftIO $ getObjectPropertyFlags obj "viewer-preferences"++data DocumentViewerPreferencesPropertyInfo+instance AttrInfo DocumentViewerPreferencesPropertyInfo where+    type AttrAllowedOps DocumentViewerPreferencesPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint DocumentViewerPreferencesPropertyInfo = (~) ()+    type AttrBaseTypeConstraint DocumentViewerPreferencesPropertyInfo = DocumentK+    type AttrGetType DocumentViewerPreferencesPropertyInfo = [ViewerPreferences]+    type AttrLabel DocumentViewerPreferencesPropertyInfo = "Document::viewer-preferences"+    attrGet _ = getDocumentViewerPreferences+    attrSet _ = undefined+    attrConstruct _ = undefined++type instance AttributeList Document = DocumentAttributeList+type DocumentAttributeList = ('[ '("author", DocumentAuthorPropertyInfo), '("creation-date", DocumentCreationDatePropertyInfo), '("creator", DocumentCreatorPropertyInfo), '("format", DocumentFormatPropertyInfo), '("format-major", DocumentFormatMajorPropertyInfo), '("format-minor", DocumentFormatMinorPropertyInfo), '("keywords", DocumentKeywordsPropertyInfo), '("linearized", DocumentLinearizedPropertyInfo), '("metadata", DocumentMetadataPropertyInfo), '("mod-date", DocumentModDatePropertyInfo), '("page-layout", DocumentPageLayoutPropertyInfo), '("page-mode", DocumentPageModePropertyInfo), '("permissions", DocumentPermissionsPropertyInfo), '("producer", DocumentProducerPropertyInfo), '("subject", DocumentSubjectPropertyInfo), '("title", DocumentTitlePropertyInfo), '("viewer-preferences", DocumentViewerPreferencesPropertyInfo)] :: [(Symbol, *)])++type instance SignalList Document = DocumentSignalList+type DocumentSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method Document::new_from_data+-- method type : Constructor+-- Args : [Arg {argName = "data", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "length", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "password", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "data", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "length", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "password", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "Document"+-- throws : True+-- Skip return : False++foreign import ccall "poppler_document_new_from_data" poppler_document_new_from_data :: +    CString ->                              -- data : TBasicType TUTF8+    Int32 ->                                -- length : TBasicType TInt32+    CString ->                              -- password : TBasicType TUTF8+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr Document)+++documentNewFromData ::+    (MonadIO m) =>+    T.Text ->                               -- data+    Int32 ->                                -- length+    Maybe (T.Text) ->                       -- password+    m Document+documentNewFromData data_ length_ password = liftIO $ do+    data_' <- textToCString data_+    maybePassword <- case password of+        Nothing -> return nullPtr+        Just jPassword -> do+            jPassword' <- textToCString jPassword+            return jPassword'+    onException (do+        result <- propagateGError $ poppler_document_new_from_data data_' length_ maybePassword+        checkUnexpectedReturnNULL "poppler_document_new_from_data" result+        result' <- (wrapObject Document) result+        freeMem data_'+        freeMem maybePassword+        return result'+     ) (do+        freeMem data_'+        freeMem maybePassword+     )++-- method Document::new_from_file+-- method type : Constructor+-- Args : [Arg {argName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "password", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "password", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "Document"+-- throws : True+-- Skip return : False++foreign import ccall "poppler_document_new_from_file" poppler_document_new_from_file :: +    CString ->                              -- uri : TBasicType TUTF8+    CString ->                              -- password : TBasicType TUTF8+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr Document)+++documentNewFromFile ::+    (MonadIO m) =>+    T.Text ->                               -- uri+    Maybe (T.Text) ->                       -- password+    m Document+documentNewFromFile uri password = liftIO $ do+    uri' <- textToCString uri+    maybePassword <- case password of+        Nothing -> return nullPtr+        Just jPassword -> do+            jPassword' <- textToCString jPassword+            return jPassword'+    onException (do+        result <- propagateGError $ poppler_document_new_from_file uri' maybePassword+        checkUnexpectedReturnNULL "poppler_document_new_from_file" result+        result' <- (wrapObject Document) result+        freeMem uri'+        freeMem maybePassword+        return result'+     ) (do+        freeMem uri'+        freeMem maybePassword+     )++-- method Document::new_from_gfile+-- method type : Constructor+-- Args : [Arg {argName = "file", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "password", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "file", argType = TInterface "Gio" "File", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "password", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "Document"+-- throws : True+-- Skip return : False++foreign import ccall "poppler_document_new_from_gfile" poppler_document_new_from_gfile :: +    Ptr Gio.File ->                         -- file : TInterface "Gio" "File"+    CString ->                              -- password : TBasicType TUTF8+    Ptr Gio.Cancellable ->                  -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr Document)+++documentNewFromGfile ::+    (MonadIO m, Gio.FileK a, Gio.CancellableK b) =>+    a ->                                    -- file+    Maybe (T.Text) ->                       -- password+    Maybe (b) ->                            -- cancellable+    m Document+documentNewFromGfile file password cancellable = liftIO $ do+    let file' = unsafeManagedPtrCastPtr file+    maybePassword <- case password of+        Nothing -> return nullPtr+        Just jPassword -> do+            jPassword' <- textToCString jPassword+            return jPassword'+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ poppler_document_new_from_gfile file' maybePassword maybeCancellable+        checkUnexpectedReturnNULL "poppler_document_new_from_gfile" result+        result' <- (wrapObject Document) result+        touchManagedPtr file+        whenJust cancellable touchManagedPtr+        freeMem maybePassword+        return result'+     ) (do+        freeMem maybePassword+     )++-- method Document::new_from_stream+-- method type : Constructor+-- Args : [Arg {argName = "stream", argType = TInterface "Gio" "InputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "length", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "password", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "stream", argType = TInterface "Gio" "InputStream", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "length", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "password", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cancellable", argType = TInterface "Gio" "Cancellable", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "Document"+-- throws : True+-- Skip return : False++foreign import ccall "poppler_document_new_from_stream" poppler_document_new_from_stream :: +    Ptr Gio.InputStream ->                  -- stream : TInterface "Gio" "InputStream"+    Int64 ->                                -- length : TBasicType TInt64+    CString ->                              -- password : TBasicType TUTF8+    Ptr Gio.Cancellable ->                  -- cancellable : TInterface "Gio" "Cancellable"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr Document)+++documentNewFromStream ::+    (MonadIO m, Gio.InputStreamK a, Gio.CancellableK b) =>+    a ->                                    -- stream+    Int64 ->                                -- length+    Maybe (T.Text) ->                       -- password+    Maybe (b) ->                            -- cancellable+    m Document+documentNewFromStream stream length_ password cancellable = liftIO $ do+    let stream' = unsafeManagedPtrCastPtr stream+    maybePassword <- case password of+        Nothing -> return nullPtr+        Just jPassword -> do+            jPassword' <- textToCString jPassword+            return jPassword'+    maybeCancellable <- case cancellable of+        Nothing -> return nullPtr+        Just jCancellable -> do+            let jCancellable' = unsafeManagedPtrCastPtr jCancellable+            return jCancellable'+    onException (do+        result <- propagateGError $ poppler_document_new_from_stream stream' length_ maybePassword maybeCancellable+        checkUnexpectedReturnNULL "poppler_document_new_from_stream" result+        result' <- (wrapObject Document) result+        touchManagedPtr stream+        whenJust cancellable touchManagedPtr+        freeMem maybePassword+        return result'+     ) (do+        freeMem maybePassword+     )++-- method Document::find_dest+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "link_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "link_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "Dest"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_document_find_dest" poppler_document_find_dest :: +    Ptr Document ->                         -- _obj : TInterface "Poppler" "Document"+    CString ->                              -- link_name : TBasicType TUTF8+    IO (Ptr Dest)+++documentFindDest ::+    (MonadIO m, DocumentK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- link_name+    m Dest+documentFindDest _obj link_name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    link_name' <- textToCString link_name+    result <- poppler_document_find_dest _obj' link_name'+    checkUnexpectedReturnNULL "poppler_document_find_dest" result+    result' <- (wrapBoxed Dest) result+    touchManagedPtr _obj+    freeMem link_name'+    return result'++-- method Document::get_attachments+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGList (TInterface "Poppler" "Attachment")+-- throws : False+-- Skip return : False++foreign import ccall "poppler_document_get_attachments" poppler_document_get_attachments :: +    Ptr Document ->                         -- _obj : TInterface "Poppler" "Document"+    IO (Ptr (GList (Ptr Attachment)))+++documentGetAttachments ::+    (MonadIO m, DocumentK a) =>+    a ->                                    -- _obj+    m [Attachment]+documentGetAttachments _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_document_get_attachments _obj'+    checkUnexpectedReturnNULL "poppler_document_get_attachments" result+    result' <- unpackGList result+    result'' <- mapM (wrapObject Attachment) result'+    g_list_free result+    touchManagedPtr _obj+    return result''++-- method Document::get_author+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "poppler_document_get_author" poppler_document_get_author :: +    Ptr Document ->                         -- _obj : TInterface "Poppler" "Document"+    IO CString+++documentGetAuthor ::+    (MonadIO m, DocumentK a) =>+    a ->                                    -- _obj+    m T.Text+documentGetAuthor _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_document_get_author _obj'+    checkUnexpectedReturnNULL "poppler_document_get_author" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method Document::get_creation_date+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt64+-- throws : False+-- Skip return : False++foreign import ccall "poppler_document_get_creation_date" poppler_document_get_creation_date :: +    Ptr Document ->                         -- _obj : TInterface "Poppler" "Document"+    IO Int64+++documentGetCreationDate ::+    (MonadIO m, DocumentK a) =>+    a ->                                    -- _obj+    m Int64+documentGetCreationDate _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_document_get_creation_date _obj'+    touchManagedPtr _obj+    return result++-- method Document::get_creator+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "poppler_document_get_creator" poppler_document_get_creator :: +    Ptr Document ->                         -- _obj : TInterface "Poppler" "Document"+    IO CString+++documentGetCreator ::+    (MonadIO m, DocumentK a) =>+    a ->                                    -- _obj+    m T.Text+documentGetCreator _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_document_get_creator _obj'+    checkUnexpectedReturnNULL "poppler_document_get_creator" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method Document::get_form_field+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "id", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "id", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "FormField"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_document_get_form_field" poppler_document_get_form_field :: +    Ptr Document ->                         -- _obj : TInterface "Poppler" "Document"+    Int32 ->                                -- id : TBasicType TInt32+    IO (Ptr FormField)+++documentGetFormField ::+    (MonadIO m, DocumentK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- id+    m FormField+documentGetFormField _obj id = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_document_get_form_field _obj' id+    checkUnexpectedReturnNULL "poppler_document_get_form_field" result+    result' <- (wrapObject FormField) result+    touchManagedPtr _obj+    return result'++-- method Document::get_id+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "permanent_id", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "update_id", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "poppler_document_get_id" poppler_document_get_id :: +    Ptr Document ->                         -- _obj : TInterface "Poppler" "Document"+    Ptr CString ->                          -- permanent_id : TBasicType TUTF8+    Ptr CString ->                          -- update_id : TBasicType TUTF8+    IO CInt+++documentGetId ::+    (MonadIO m, DocumentK a) =>+    a ->                                    -- _obj+    m (Bool,T.Text,T.Text)+documentGetId _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    permanent_id <- allocMem :: IO (Ptr CString)+    update_id <- allocMem :: IO (Ptr CString)+    result <- poppler_document_get_id _obj' permanent_id update_id+    let result' = (/= 0) result+    permanent_id' <- peek permanent_id+    permanent_id'' <- cstringToText permanent_id'+    freeMem permanent_id'+    update_id' <- peek update_id+    update_id'' <- cstringToText update_id'+    freeMem update_id'+    touchManagedPtr _obj+    freeMem permanent_id+    freeMem update_id+    return (result', permanent_id'', update_id'')++-- method Document::get_keywords+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "poppler_document_get_keywords" poppler_document_get_keywords :: +    Ptr Document ->                         -- _obj : TInterface "Poppler" "Document"+    IO CString+++documentGetKeywords ::+    (MonadIO m, DocumentK a) =>+    a ->                                    -- _obj+    m T.Text+documentGetKeywords _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_document_get_keywords _obj'+    checkUnexpectedReturnNULL "poppler_document_get_keywords" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method Document::get_metadata+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "poppler_document_get_metadata" poppler_document_get_metadata :: +    Ptr Document ->                         -- _obj : TInterface "Poppler" "Document"+    IO CString+++documentGetMetadata ::+    (MonadIO m, DocumentK a) =>+    a ->                                    -- _obj+    m T.Text+documentGetMetadata _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_document_get_metadata _obj'+    checkUnexpectedReturnNULL "poppler_document_get_metadata" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method Document::get_modification_date+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt64+-- throws : False+-- Skip return : False++foreign import ccall "poppler_document_get_modification_date" poppler_document_get_modification_date :: +    Ptr Document ->                         -- _obj : TInterface "Poppler" "Document"+    IO Int64+++documentGetModificationDate ::+    (MonadIO m, DocumentK a) =>+    a ->                                    -- _obj+    m Int64+documentGetModificationDate _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_document_get_modification_date _obj'+    touchManagedPtr _obj+    return result++-- method Document::get_n_attachments+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "poppler_document_get_n_attachments" poppler_document_get_n_attachments :: +    Ptr Document ->                         -- _obj : TInterface "Poppler" "Document"+    IO Word32+++documentGetNAttachments ::+    (MonadIO m, DocumentK a) =>+    a ->                                    -- _obj+    m Word32+documentGetNAttachments _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_document_get_n_attachments _obj'+    touchManagedPtr _obj+    return result++-- method Document::get_n_pages+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "poppler_document_get_n_pages" poppler_document_get_n_pages :: +    Ptr Document ->                         -- _obj : TInterface "Poppler" "Document"+    IO Int32+++documentGetNPages ::+    (MonadIO m, DocumentK a) =>+    a ->                                    -- _obj+    m Int32+documentGetNPages _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_document_get_n_pages _obj'+    touchManagedPtr _obj+    return result++-- method Document::get_page+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "index", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "index", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "Page"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_document_get_page" poppler_document_get_page :: +    Ptr Document ->                         -- _obj : TInterface "Poppler" "Document"+    Int32 ->                                -- index : TBasicType TInt32+    IO (Ptr Page)+++documentGetPage ::+    (MonadIO m, DocumentK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- index+    m Page+documentGetPage _obj index = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_document_get_page _obj' index+    checkUnexpectedReturnNULL "poppler_document_get_page" result+    result' <- (wrapObject Page) result+    touchManagedPtr _obj+    return result'++-- method Document::get_page_by_label+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "Page"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_document_get_page_by_label" poppler_document_get_page_by_label :: +    Ptr Document ->                         -- _obj : TInterface "Poppler" "Document"+    CString ->                              -- label : TBasicType TUTF8+    IO (Ptr Page)+++documentGetPageByLabel ::+    (MonadIO m, DocumentK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- label+    m Page+documentGetPageByLabel _obj label = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    label' <- textToCString label+    result <- poppler_document_get_page_by_label _obj' label'+    checkUnexpectedReturnNULL "poppler_document_get_page_by_label" result+    result' <- (wrapObject Page) result+    touchManagedPtr _obj+    freeMem label'+    return result'++-- method Document::get_page_layout+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "PageLayout"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_document_get_page_layout" poppler_document_get_page_layout :: +    Ptr Document ->                         -- _obj : TInterface "Poppler" "Document"+    IO CUInt+++documentGetPageLayout ::+    (MonadIO m, DocumentK a) =>+    a ->                                    -- _obj+    m PageLayout+documentGetPageLayout _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_document_get_page_layout _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method Document::get_page_mode+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "PageMode"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_document_get_page_mode" poppler_document_get_page_mode :: +    Ptr Document ->                         -- _obj : TInterface "Poppler" "Document"+    IO CUInt+++documentGetPageMode ::+    (MonadIO m, DocumentK a) =>+    a ->                                    -- _obj+    m PageMode+documentGetPageMode _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_document_get_page_mode _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method Document::get_pdf_version+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "major_version", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "minor_version", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_document_get_pdf_version" poppler_document_get_pdf_version :: +    Ptr Document ->                         -- _obj : TInterface "Poppler" "Document"+    Ptr Word32 ->                           -- major_version : TBasicType TUInt32+    Ptr Word32 ->                           -- minor_version : TBasicType TUInt32+    IO ()+++documentGetPdfVersion ::+    (MonadIO m, DocumentK a) =>+    a ->                                    -- _obj+    m (Word32,Word32)+documentGetPdfVersion _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    major_version <- allocMem :: IO (Ptr Word32)+    minor_version <- allocMem :: IO (Ptr Word32)+    poppler_document_get_pdf_version _obj' major_version minor_version+    major_version' <- peek major_version+    minor_version' <- peek minor_version+    touchManagedPtr _obj+    freeMem major_version+    freeMem minor_version+    return (major_version', minor_version')++-- method Document::get_pdf_version_string+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "poppler_document_get_pdf_version_string" poppler_document_get_pdf_version_string :: +    Ptr Document ->                         -- _obj : TInterface "Poppler" "Document"+    IO CString+++documentGetPdfVersionString ::+    (MonadIO m, DocumentK a) =>+    a ->                                    -- _obj+    m T.Text+documentGetPdfVersionString _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_document_get_pdf_version_string _obj'+    checkUnexpectedReturnNULL "poppler_document_get_pdf_version_string" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method Document::get_permissions+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "Permissions"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_document_get_permissions" poppler_document_get_permissions :: +    Ptr Document ->                         -- _obj : TInterface "Poppler" "Document"+    IO CUInt+++documentGetPermissions ::+    (MonadIO m, DocumentK a) =>+    a ->                                    -- _obj+    m [Permissions]+documentGetPermissions _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_document_get_permissions _obj'+    let result' = wordToGFlags result+    touchManagedPtr _obj+    return result'++-- method Document::get_producer+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "poppler_document_get_producer" poppler_document_get_producer :: +    Ptr Document ->                         -- _obj : TInterface "Poppler" "Document"+    IO CString+++documentGetProducer ::+    (MonadIO m, DocumentK a) =>+    a ->                                    -- _obj+    m T.Text+documentGetProducer _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_document_get_producer _obj'+    checkUnexpectedReturnNULL "poppler_document_get_producer" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method Document::get_subject+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "poppler_document_get_subject" poppler_document_get_subject :: +    Ptr Document ->                         -- _obj : TInterface "Poppler" "Document"+    IO CString+++documentGetSubject ::+    (MonadIO m, DocumentK a) =>+    a ->                                    -- _obj+    m T.Text+documentGetSubject _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_document_get_subject _obj'+    checkUnexpectedReturnNULL "poppler_document_get_subject" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method Document::get_title+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "poppler_document_get_title" poppler_document_get_title :: +    Ptr Document ->                         -- _obj : TInterface "Poppler" "Document"+    IO CString+++documentGetTitle ::+    (MonadIO m, DocumentK a) =>+    a ->                                    -- _obj+    m T.Text+documentGetTitle _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_document_get_title _obj'+    checkUnexpectedReturnNULL "poppler_document_get_title" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method Document::has_attachments+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "poppler_document_has_attachments" poppler_document_has_attachments :: +    Ptr Document ->                         -- _obj : TInterface "Poppler" "Document"+    IO CInt+++documentHasAttachments ::+    (MonadIO m, DocumentK a) =>+    a ->                                    -- _obj+    m Bool+documentHasAttachments _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_document_has_attachments _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Document::is_linearized+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "poppler_document_is_linearized" poppler_document_is_linearized :: +    Ptr Document ->                         -- _obj : TInterface "Poppler" "Document"+    IO CInt+++documentIsLinearized ::+    (MonadIO m, DocumentK a) =>+    a ->                                    -- _obj+    m Bool+documentIsLinearized _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_document_is_linearized _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Document::save+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "poppler_document_save" poppler_document_save :: +    Ptr Document ->                         -- _obj : TInterface "Poppler" "Document"+    CString ->                              -- uri : TBasicType TUTF8+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++documentSave ::+    (MonadIO m, DocumentK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- uri+    m ()+documentSave _obj uri = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    uri' <- textToCString uri+    onException (do+        _ <- propagateGError $ poppler_document_save _obj' uri'+        touchManagedPtr _obj+        freeMem uri'+        return ()+     ) (do+        freeMem uri'+     )++-- method Document::save_a_copy+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "poppler_document_save_a_copy" poppler_document_save_a_copy :: +    Ptr Document ->                         -- _obj : TInterface "Poppler" "Document"+    CString ->                              -- uri : TBasicType TUTF8+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++documentSaveACopy ::+    (MonadIO m, DocumentK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- uri+    m ()+documentSaveACopy _obj uri = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    uri' <- textToCString uri+    onException (do+        _ <- propagateGError $ poppler_document_save_a_copy _obj' uri'+        touchManagedPtr _obj+        freeMem uri'+        return ()+     ) (do+        freeMem uri'+     )++
+ GI/Poppler/Objects/Document.hs-boot view
@@ -0,0 +1,30 @@+module GI.Poppler.Objects.Document where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype Document = Document (ForeignPtr Document)+instance GObject Document where+class GObject o => DocumentK o+instance (GObject o, IsDescendantOf Document o) => DocumentK o+data DocumentAuthorPropertyInfo+data DocumentCreationDatePropertyInfo+data DocumentCreatorPropertyInfo+data DocumentFormatPropertyInfo+data DocumentFormatMajorPropertyInfo+data DocumentFormatMinorPropertyInfo+data DocumentKeywordsPropertyInfo+data DocumentLinearizedPropertyInfo+data DocumentMetadataPropertyInfo+data DocumentModDatePropertyInfo+data DocumentPageLayoutPropertyInfo+data DocumentPageModePropertyInfo+data DocumentPermissionsPropertyInfo+data DocumentProducerPropertyInfo+data DocumentSubjectPropertyInfo+data DocumentTitlePropertyInfo+data DocumentViewerPreferencesPropertyInfo
+ GI/Poppler/Objects/FontInfo.hs view
@@ -0,0 +1,155 @@++{- |+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.FontInfo+    ( ++-- * Exported types+    FontInfo(..)                            ,+    FontInfoK                               ,+    toFontInfo                              ,+    noFontInfo                              ,+++ -- * Methods+-- ** fontInfoFree+    fontInfoFree                            ,+++-- ** fontInfoNew+    fontInfoNew                             ,+++-- ** fontInfoScan+    fontInfoScan                            ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Poppler.Types+import GI.Poppler.Callbacks+import qualified GI.GObject as GObject++newtype FontInfo = FontInfo (ForeignPtr FontInfo)+foreign import ccall "poppler_font_info_get_type"+    c_poppler_font_info_get_type :: IO GType++type instance ParentTypes FontInfo = FontInfoParentTypes+type FontInfoParentTypes = '[GObject.Object]++instance GObject FontInfo where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_poppler_font_info_get_type+    ++class GObject o => FontInfoK o+instance (GObject o, IsDescendantOf FontInfo o) => FontInfoK o++toFontInfo :: FontInfoK o => o -> IO FontInfo+toFontInfo = unsafeCastTo FontInfo++noFontInfo :: Maybe FontInfo+noFontInfo = Nothing++type instance AttributeList FontInfo = FontInfoAttributeList+type FontInfoAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList FontInfo = FontInfoSignalList+type FontInfoSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method FontInfo::new+-- method type : Constructor+-- Args : [Arg {argName = "document", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "document", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "FontInfo"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_font_info_new" poppler_font_info_new :: +    Ptr Document ->                         -- document : TInterface "Poppler" "Document"+    IO (Ptr FontInfo)+++fontInfoNew ::+    (MonadIO m, DocumentK a) =>+    a ->                                    -- document+    m FontInfo+fontInfoNew document = liftIO $ do+    let document' = unsafeManagedPtrCastPtr document+    result <- poppler_font_info_new document'+    checkUnexpectedReturnNULL "poppler_font_info_new" result+    result' <- (wrapObject FontInfo) result+    touchManagedPtr document+    return result'++-- method FontInfo::free+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "FontInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "FontInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_font_info_free" poppler_font_info_free :: +    Ptr FontInfo ->                         -- _obj : TInterface "Poppler" "FontInfo"+    IO ()+++fontInfoFree ::+    (MonadIO m, FontInfoK a) =>+    a ->                                    -- _obj+    m ()+fontInfoFree _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    poppler_font_info_free _obj'+    touchManagedPtr _obj+    return ()++-- method FontInfo::scan+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "FontInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_pages", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "iter", argType = TInterface "Poppler" "FontsIter", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "FontInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_pages", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "poppler_font_info_scan" poppler_font_info_scan :: +    Ptr FontInfo ->                         -- _obj : TInterface "Poppler" "FontInfo"+    Int32 ->                                -- n_pages : TBasicType TInt32+    Ptr (Ptr FontsIter) ->                  -- iter : TInterface "Poppler" "FontsIter"+    IO CInt+++fontInfoScan ::+    (MonadIO m, FontInfoK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- n_pages+    m (Bool,FontsIter)+fontInfoScan _obj n_pages = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    iter <- allocMem :: IO (Ptr (Ptr FontsIter))+    result <- poppler_font_info_scan _obj' n_pages iter+    let result' = (/= 0) result+    iter' <- peek iter+    iter'' <- (wrapBoxed FontsIter) iter'+    touchManagedPtr _obj+    freeMem iter+    return (result', iter'')++
+ GI/Poppler/Objects/FontInfo.hs-boot view
@@ -0,0 +1,13 @@+module GI.Poppler.Objects.FontInfo where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype FontInfo = FontInfo (ForeignPtr FontInfo)+instance GObject FontInfo where+class GObject o => FontInfoK o+instance (GObject o, IsDescendantOf FontInfo o) => FontInfoK o
+ GI/Poppler/Objects/FormField.hs view
@@ -0,0 +1,1012 @@++{- |+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.FormField+    ( ++-- * Exported types+    FormField(..)                           ,+    FormFieldK                              ,+    toFormField                             ,+    noFormField                             ,+++ -- * Methods+-- ** formFieldButtonGetButtonType+    formFieldButtonGetButtonType            ,+++-- ** formFieldButtonGetState+    formFieldButtonGetState                 ,+++-- ** formFieldButtonSetState+    formFieldButtonSetState                 ,+++-- ** formFieldChoiceCanSelectMultiple+    formFieldChoiceCanSelectMultiple        ,+++-- ** formFieldChoiceCommitOnChange+    formFieldChoiceCommitOnChange           ,+++-- ** formFieldChoiceDoSpellCheck+    formFieldChoiceDoSpellCheck             ,+++-- ** formFieldChoiceGetChoiceType+    formFieldChoiceGetChoiceType            ,+++-- ** formFieldChoiceGetItem+    formFieldChoiceGetItem                  ,+++-- ** formFieldChoiceGetNItems+    formFieldChoiceGetNItems                ,+++-- ** formFieldChoiceGetText+    formFieldChoiceGetText                  ,+++-- ** formFieldChoiceIsEditable+    formFieldChoiceIsEditable               ,+++-- ** formFieldChoiceIsItemSelected+    formFieldChoiceIsItemSelected           ,+++-- ** formFieldChoiceSelectItem+    formFieldChoiceSelectItem               ,+++-- ** formFieldChoiceSetText+    formFieldChoiceSetText                  ,+++-- ** formFieldChoiceToggleItem+    formFieldChoiceToggleItem               ,+++-- ** formFieldChoiceUnselectAll+    formFieldChoiceUnselectAll              ,+++-- ** formFieldGetAction+    formFieldGetAction                      ,+++-- ** formFieldGetFieldType+    formFieldGetFieldType                   ,+++-- ** formFieldGetFontSize+    formFieldGetFontSize                    ,+++-- ** formFieldGetId+    formFieldGetId                          ,+++-- ** formFieldGetMappingName+    formFieldGetMappingName                 ,+++-- ** formFieldGetName+    formFieldGetName                        ,+++-- ** formFieldGetPartialName+    formFieldGetPartialName                 ,+++-- ** formFieldIsReadOnly+    formFieldIsReadOnly                     ,+++-- ** formFieldTextDoScroll+    formFieldTextDoScroll                   ,+++-- ** formFieldTextDoSpellCheck+    formFieldTextDoSpellCheck               ,+++-- ** formFieldTextGetMaxLen+    formFieldTextGetMaxLen                  ,+++-- ** formFieldTextGetText+    formFieldTextGetText                    ,+++-- ** formFieldTextGetTextType+    formFieldTextGetTextType                ,+++-- ** formFieldTextIsPassword+    formFieldTextIsPassword                 ,+++-- ** formFieldTextIsRichText+    formFieldTextIsRichText                 ,+++-- ** formFieldTextSetText+    formFieldTextSetText                    ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Poppler.Types+import GI.Poppler.Callbacks+import qualified GI.GObject as GObject++newtype FormField = FormField (ForeignPtr FormField)+foreign import ccall "poppler_form_field_get_type"+    c_poppler_form_field_get_type :: IO GType++type instance ParentTypes FormField = FormFieldParentTypes+type FormFieldParentTypes = '[GObject.Object]++instance GObject FormField where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_poppler_form_field_get_type+    ++class GObject o => FormFieldK o+instance (GObject o, IsDescendantOf FormField o) => FormFieldK o++toFormField :: FormFieldK o => o -> IO FormField+toFormField = unsafeCastTo FormField++noFormField :: Maybe FormField+noFormField = Nothing++type instance AttributeList FormField = FormFieldAttributeList+type FormFieldAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList FormField = FormFieldSignalList+type FormFieldSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method FormField::button_get_button_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "FormButtonType"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_form_field_button_get_button_type" poppler_form_field_button_get_button_type :: +    Ptr FormField ->                        -- _obj : TInterface "Poppler" "FormField"+    IO CUInt+++formFieldButtonGetButtonType ::+    (MonadIO m, FormFieldK a) =>+    a ->                                    -- _obj+    m FormButtonType+formFieldButtonGetButtonType _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_form_field_button_get_button_type _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method FormField::button_get_state+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "poppler_form_field_button_get_state" poppler_form_field_button_get_state :: +    Ptr FormField ->                        -- _obj : TInterface "Poppler" "FormField"+    IO CInt+++formFieldButtonGetState ::+    (MonadIO m, FormFieldK a) =>+    a ->                                    -- _obj+    m Bool+formFieldButtonGetState _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_form_field_button_get_state _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method FormField::button_set_state+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "state", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "state", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_form_field_button_set_state" poppler_form_field_button_set_state :: +    Ptr FormField ->                        -- _obj : TInterface "Poppler" "FormField"+    CInt ->                                 -- state : TBasicType TBoolean+    IO ()+++formFieldButtonSetState ::+    (MonadIO m, FormFieldK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- state+    m ()+formFieldButtonSetState _obj state = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let state' = (fromIntegral . fromEnum) state+    poppler_form_field_button_set_state _obj' state'+    touchManagedPtr _obj+    return ()++-- method FormField::choice_can_select_multiple+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "poppler_form_field_choice_can_select_multiple" poppler_form_field_choice_can_select_multiple :: +    Ptr FormField ->                        -- _obj : TInterface "Poppler" "FormField"+    IO CInt+++formFieldChoiceCanSelectMultiple ::+    (MonadIO m, FormFieldK a) =>+    a ->                                    -- _obj+    m Bool+formFieldChoiceCanSelectMultiple _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_form_field_choice_can_select_multiple _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method FormField::choice_commit_on_change+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "poppler_form_field_choice_commit_on_change" poppler_form_field_choice_commit_on_change :: +    Ptr FormField ->                        -- _obj : TInterface "Poppler" "FormField"+    IO CInt+++formFieldChoiceCommitOnChange ::+    (MonadIO m, FormFieldK a) =>+    a ->                                    -- _obj+    m Bool+formFieldChoiceCommitOnChange _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_form_field_choice_commit_on_change _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method FormField::choice_do_spell_check+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "poppler_form_field_choice_do_spell_check" poppler_form_field_choice_do_spell_check :: +    Ptr FormField ->                        -- _obj : TInterface "Poppler" "FormField"+    IO CInt+++formFieldChoiceDoSpellCheck ::+    (MonadIO m, FormFieldK a) =>+    a ->                                    -- _obj+    m Bool+formFieldChoiceDoSpellCheck _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_form_field_choice_do_spell_check _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method FormField::choice_get_choice_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "FormChoiceType"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_form_field_choice_get_choice_type" poppler_form_field_choice_get_choice_type :: +    Ptr FormField ->                        -- _obj : TInterface "Poppler" "FormField"+    IO CUInt+++formFieldChoiceGetChoiceType ::+    (MonadIO m, FormFieldK a) =>+    a ->                                    -- _obj+    m FormChoiceType+formFieldChoiceGetChoiceType _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_form_field_choice_get_choice_type _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method FormField::choice_get_item+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "index", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "index", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "poppler_form_field_choice_get_item" poppler_form_field_choice_get_item :: +    Ptr FormField ->                        -- _obj : TInterface "Poppler" "FormField"+    Int32 ->                                -- index : TBasicType TInt32+    IO CString+++formFieldChoiceGetItem ::+    (MonadIO m, FormFieldK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- index+    m T.Text+formFieldChoiceGetItem _obj index = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_form_field_choice_get_item _obj' index+    checkUnexpectedReturnNULL "poppler_form_field_choice_get_item" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method FormField::choice_get_n_items+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "poppler_form_field_choice_get_n_items" poppler_form_field_choice_get_n_items :: +    Ptr FormField ->                        -- _obj : TInterface "Poppler" "FormField"+    IO Int32+++formFieldChoiceGetNItems ::+    (MonadIO m, FormFieldK a) =>+    a ->                                    -- _obj+    m Int32+formFieldChoiceGetNItems _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_form_field_choice_get_n_items _obj'+    touchManagedPtr _obj+    return result++-- method FormField::choice_get_text+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "poppler_form_field_choice_get_text" poppler_form_field_choice_get_text :: +    Ptr FormField ->                        -- _obj : TInterface "Poppler" "FormField"+    IO CString+++formFieldChoiceGetText ::+    (MonadIO m, FormFieldK a) =>+    a ->                                    -- _obj+    m T.Text+formFieldChoiceGetText _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_form_field_choice_get_text _obj'+    checkUnexpectedReturnNULL "poppler_form_field_choice_get_text" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method FormField::choice_is_editable+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "poppler_form_field_choice_is_editable" poppler_form_field_choice_is_editable :: +    Ptr FormField ->                        -- _obj : TInterface "Poppler" "FormField"+    IO CInt+++formFieldChoiceIsEditable ::+    (MonadIO m, FormFieldK a) =>+    a ->                                    -- _obj+    m Bool+formFieldChoiceIsEditable _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_form_field_choice_is_editable _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method FormField::choice_is_item_selected+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "index", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "index", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "poppler_form_field_choice_is_item_selected" poppler_form_field_choice_is_item_selected :: +    Ptr FormField ->                        -- _obj : TInterface "Poppler" "FormField"+    Int32 ->                                -- index : TBasicType TInt32+    IO CInt+++formFieldChoiceIsItemSelected ::+    (MonadIO m, FormFieldK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- index+    m Bool+formFieldChoiceIsItemSelected _obj index = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_form_field_choice_is_item_selected _obj' index+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method FormField::choice_select_item+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "index", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "index", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_form_field_choice_select_item" poppler_form_field_choice_select_item :: +    Ptr FormField ->                        -- _obj : TInterface "Poppler" "FormField"+    Int32 ->                                -- index : TBasicType TInt32+    IO ()+++formFieldChoiceSelectItem ::+    (MonadIO m, FormFieldK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- index+    m ()+formFieldChoiceSelectItem _obj index = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    poppler_form_field_choice_select_item _obj' index+    touchManagedPtr _obj+    return ()++-- method FormField::choice_set_text+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_form_field_choice_set_text" poppler_form_field_choice_set_text :: +    Ptr FormField ->                        -- _obj : TInterface "Poppler" "FormField"+    CString ->                              -- text : TBasicType TUTF8+    IO ()+++formFieldChoiceSetText ::+    (MonadIO m, FormFieldK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- text+    m ()+formFieldChoiceSetText _obj text = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    text' <- textToCString text+    poppler_form_field_choice_set_text _obj' text'+    touchManagedPtr _obj+    freeMem text'+    return ()++-- method FormField::choice_toggle_item+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "index", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "index", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_form_field_choice_toggle_item" poppler_form_field_choice_toggle_item :: +    Ptr FormField ->                        -- _obj : TInterface "Poppler" "FormField"+    Int32 ->                                -- index : TBasicType TInt32+    IO ()+++formFieldChoiceToggleItem ::+    (MonadIO m, FormFieldK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- index+    m ()+formFieldChoiceToggleItem _obj index = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    poppler_form_field_choice_toggle_item _obj' index+    touchManagedPtr _obj+    return ()++-- method FormField::choice_unselect_all+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_form_field_choice_unselect_all" poppler_form_field_choice_unselect_all :: +    Ptr FormField ->                        -- _obj : TInterface "Poppler" "FormField"+    IO ()+++formFieldChoiceUnselectAll ::+    (MonadIO m, FormFieldK a) =>+    a ->                                    -- _obj+    m ()+formFieldChoiceUnselectAll _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    poppler_form_field_choice_unselect_all _obj'+    touchManagedPtr _obj+    return ()++-- method FormField::get_action+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "Action"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_form_field_get_action" poppler_form_field_get_action :: +    Ptr FormField ->                        -- _obj : TInterface "Poppler" "FormField"+    IO (Ptr Action)+++formFieldGetAction ::+    (MonadIO m, FormFieldK a) =>+    a ->                                    -- _obj+    m Action+formFieldGetAction _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_form_field_get_action _obj'+    checkUnexpectedReturnNULL "poppler_form_field_get_action" result+    result' <- (newBoxed Action) result+    touchManagedPtr _obj+    return result'++-- method FormField::get_field_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "FormFieldType"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_form_field_get_field_type" poppler_form_field_get_field_type :: +    Ptr FormField ->                        -- _obj : TInterface "Poppler" "FormField"+    IO CUInt+++formFieldGetFieldType ::+    (MonadIO m, FormFieldK a) =>+    a ->                                    -- _obj+    m FormFieldType+formFieldGetFieldType _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_form_field_get_field_type _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method FormField::get_font_size+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TDouble+-- throws : False+-- Skip return : False++foreign import ccall "poppler_form_field_get_font_size" poppler_form_field_get_font_size :: +    Ptr FormField ->                        -- _obj : TInterface "Poppler" "FormField"+    IO CDouble+++formFieldGetFontSize ::+    (MonadIO m, FormFieldK a) =>+    a ->                                    -- _obj+    m Double+formFieldGetFontSize _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_form_field_get_font_size _obj'+    let result' = realToFrac result+    touchManagedPtr _obj+    return result'++-- method FormField::get_id+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "poppler_form_field_get_id" poppler_form_field_get_id :: +    Ptr FormField ->                        -- _obj : TInterface "Poppler" "FormField"+    IO Int32+++formFieldGetId ::+    (MonadIO m, FormFieldK a) =>+    a ->                                    -- _obj+    m Int32+formFieldGetId _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_form_field_get_id _obj'+    touchManagedPtr _obj+    return result++-- method FormField::get_mapping_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "poppler_form_field_get_mapping_name" poppler_form_field_get_mapping_name :: +    Ptr FormField ->                        -- _obj : TInterface "Poppler" "FormField"+    IO CString+++formFieldGetMappingName ::+    (MonadIO m, FormFieldK a) =>+    a ->                                    -- _obj+    m T.Text+formFieldGetMappingName _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_form_field_get_mapping_name _obj'+    checkUnexpectedReturnNULL "poppler_form_field_get_mapping_name" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method FormField::get_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "poppler_form_field_get_name" poppler_form_field_get_name :: +    Ptr FormField ->                        -- _obj : TInterface "Poppler" "FormField"+    IO CString+++formFieldGetName ::+    (MonadIO m, FormFieldK a) =>+    a ->                                    -- _obj+    m T.Text+formFieldGetName _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_form_field_get_name _obj'+    checkUnexpectedReturnNULL "poppler_form_field_get_name" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method FormField::get_partial_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "poppler_form_field_get_partial_name" poppler_form_field_get_partial_name :: +    Ptr FormField ->                        -- _obj : TInterface "Poppler" "FormField"+    IO CString+++formFieldGetPartialName ::+    (MonadIO m, FormFieldK a) =>+    a ->                                    -- _obj+    m T.Text+formFieldGetPartialName _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_form_field_get_partial_name _obj'+    checkUnexpectedReturnNULL "poppler_form_field_get_partial_name" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method FormField::is_read_only+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "poppler_form_field_is_read_only" poppler_form_field_is_read_only :: +    Ptr FormField ->                        -- _obj : TInterface "Poppler" "FormField"+    IO CInt+++formFieldIsReadOnly ::+    (MonadIO m, FormFieldK a) =>+    a ->                                    -- _obj+    m Bool+formFieldIsReadOnly _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_form_field_is_read_only _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method FormField::text_do_scroll+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "poppler_form_field_text_do_scroll" poppler_form_field_text_do_scroll :: +    Ptr FormField ->                        -- _obj : TInterface "Poppler" "FormField"+    IO CInt+++formFieldTextDoScroll ::+    (MonadIO m, FormFieldK a) =>+    a ->                                    -- _obj+    m Bool+formFieldTextDoScroll _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_form_field_text_do_scroll _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method FormField::text_do_spell_check+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "poppler_form_field_text_do_spell_check" poppler_form_field_text_do_spell_check :: +    Ptr FormField ->                        -- _obj : TInterface "Poppler" "FormField"+    IO CInt+++formFieldTextDoSpellCheck ::+    (MonadIO m, FormFieldK a) =>+    a ->                                    -- _obj+    m Bool+formFieldTextDoSpellCheck _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_form_field_text_do_spell_check _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method FormField::text_get_max_len+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "poppler_form_field_text_get_max_len" poppler_form_field_text_get_max_len :: +    Ptr FormField ->                        -- _obj : TInterface "Poppler" "FormField"+    IO Int32+++formFieldTextGetMaxLen ::+    (MonadIO m, FormFieldK a) =>+    a ->                                    -- _obj+    m Int32+formFieldTextGetMaxLen _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_form_field_text_get_max_len _obj'+    touchManagedPtr _obj+    return result++-- method FormField::text_get_text+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "poppler_form_field_text_get_text" poppler_form_field_text_get_text :: +    Ptr FormField ->                        -- _obj : TInterface "Poppler" "FormField"+    IO CString+++formFieldTextGetText ::+    (MonadIO m, FormFieldK a) =>+    a ->                                    -- _obj+    m T.Text+formFieldTextGetText _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_form_field_text_get_text _obj'+    checkUnexpectedReturnNULL "poppler_form_field_text_get_text" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method FormField::text_get_text_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "FormTextType"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_form_field_text_get_text_type" poppler_form_field_text_get_text_type :: +    Ptr FormField ->                        -- _obj : TInterface "Poppler" "FormField"+    IO CUInt+++formFieldTextGetTextType ::+    (MonadIO m, FormFieldK a) =>+    a ->                                    -- _obj+    m FormTextType+formFieldTextGetTextType _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_form_field_text_get_text_type _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method FormField::text_is_password+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "poppler_form_field_text_is_password" poppler_form_field_text_is_password :: +    Ptr FormField ->                        -- _obj : TInterface "Poppler" "FormField"+    IO CInt+++formFieldTextIsPassword ::+    (MonadIO m, FormFieldK a) =>+    a ->                                    -- _obj+    m Bool+formFieldTextIsPassword _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_form_field_text_is_password _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method FormField::text_is_rich_text+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "poppler_form_field_text_is_rich_text" poppler_form_field_text_is_rich_text :: +    Ptr FormField ->                        -- _obj : TInterface "Poppler" "FormField"+    IO CInt+++formFieldTextIsRichText ::+    (MonadIO m, FormFieldK a) =>+    a ->                                    -- _obj+    m Bool+formFieldTextIsRichText _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_form_field_text_is_rich_text _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method FormField::text_set_text+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormField", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_form_field_text_set_text" poppler_form_field_text_set_text :: +    Ptr FormField ->                        -- _obj : TInterface "Poppler" "FormField"+    CString ->                              -- text : TBasicType TUTF8+    IO ()+++formFieldTextSetText ::+    (MonadIO m, FormFieldK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- text+    m ()+formFieldTextSetText _obj text = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    text' <- textToCString text+    poppler_form_field_text_set_text _obj' text'+    touchManagedPtr _obj+    freeMem text'+    return ()++
+ GI/Poppler/Objects/FormField.hs-boot view
@@ -0,0 +1,13 @@+module GI.Poppler.Objects.FormField where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype FormField = FormField (ForeignPtr FormField)+instance GObject FormField where+class GObject o => FormFieldK o+instance (GObject o, IsDescendantOf FormField o) => FormFieldK o
+ GI/Poppler/Objects/Layer.hs view
@@ -0,0 +1,233 @@++{- |+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.Layer+    ( ++-- * Exported types+    Layer(..)                               ,+    LayerK                                  ,+    toLayer                                 ,+    noLayer                                 ,+++ -- * Methods+-- ** layerGetRadioButtonGroupId+    layerGetRadioButtonGroupId              ,+++-- ** layerGetTitle+    layerGetTitle                           ,+++-- ** layerHide+    layerHide                               ,+++-- ** layerIsParent+    layerIsParent                           ,+++-- ** layerIsVisible+    layerIsVisible                          ,+++-- ** layerShow+    layerShow                               ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Poppler.Types+import GI.Poppler.Callbacks+import qualified GI.GObject as GObject++newtype Layer = Layer (ForeignPtr Layer)+foreign import ccall "poppler_layer_get_type"+    c_poppler_layer_get_type :: IO GType++type instance ParentTypes Layer = LayerParentTypes+type LayerParentTypes = '[GObject.Object]++instance GObject Layer where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_poppler_layer_get_type+    ++class GObject o => LayerK o+instance (GObject o, IsDescendantOf Layer o) => LayerK o++toLayer :: LayerK o => o -> IO Layer+toLayer = unsafeCastTo Layer++noLayer :: Maybe Layer+noLayer = Nothing++type instance AttributeList Layer = LayerAttributeList+type LayerAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList Layer = LayerSignalList+type LayerSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method Layer::get_radio_button_group_id+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Layer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Layer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "poppler_layer_get_radio_button_group_id" poppler_layer_get_radio_button_group_id :: +    Ptr Layer ->                            -- _obj : TInterface "Poppler" "Layer"+    IO Int32+++layerGetRadioButtonGroupId ::+    (MonadIO m, LayerK a) =>+    a ->                                    -- _obj+    m Int32+layerGetRadioButtonGroupId _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_layer_get_radio_button_group_id _obj'+    touchManagedPtr _obj+    return result++-- method Layer::get_title+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Layer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Layer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "poppler_layer_get_title" poppler_layer_get_title :: +    Ptr Layer ->                            -- _obj : TInterface "Poppler" "Layer"+    IO CString+++layerGetTitle ::+    (MonadIO m, LayerK a) =>+    a ->                                    -- _obj+    m T.Text+layerGetTitle _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_layer_get_title _obj'+    checkUnexpectedReturnNULL "poppler_layer_get_title" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method Layer::hide+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Layer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Layer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_layer_hide" poppler_layer_hide :: +    Ptr Layer ->                            -- _obj : TInterface "Poppler" "Layer"+    IO ()+++layerHide ::+    (MonadIO m, LayerK a) =>+    a ->                                    -- _obj+    m ()+layerHide _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    poppler_layer_hide _obj'+    touchManagedPtr _obj+    return ()++-- method Layer::is_parent+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Layer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Layer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "poppler_layer_is_parent" poppler_layer_is_parent :: +    Ptr Layer ->                            -- _obj : TInterface "Poppler" "Layer"+    IO CInt+++layerIsParent ::+    (MonadIO m, LayerK a) =>+    a ->                                    -- _obj+    m Bool+layerIsParent _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_layer_is_parent _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Layer::is_visible+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Layer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Layer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "poppler_layer_is_visible" poppler_layer_is_visible :: +    Ptr Layer ->                            -- _obj : TInterface "Poppler" "Layer"+    IO CInt+++layerIsVisible ::+    (MonadIO m, LayerK a) =>+    a ->                                    -- _obj+    m Bool+layerIsVisible _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_layer_is_visible _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Layer::show+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Layer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Layer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_layer_show" poppler_layer_show :: +    Ptr Layer ->                            -- _obj : TInterface "Poppler" "Layer"+    IO ()+++layerShow ::+    (MonadIO m, LayerK a) =>+    a ->                                    -- _obj+    m ()+layerShow _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    poppler_layer_show _obj'+    touchManagedPtr _obj+    return ()++
+ GI/Poppler/Objects/Layer.hs-boot view
@@ -0,0 +1,13 @@+module GI.Poppler.Objects.Layer where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype Layer = Layer (ForeignPtr Layer)+instance GObject Layer where+class GObject o => LayerK o+instance (GObject o, IsDescendantOf Layer o) => LayerK o
+ GI/Poppler/Objects/Media.hs view
@@ -0,0 +1,227 @@++{- |+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.Media+    ( ++-- * Exported types+    Media(..)                               ,+    MediaK                                  ,+    toMedia                                 ,+    noMedia                                 ,+++ -- * Methods+-- ** mediaGetFilename+    mediaGetFilename                        ,+++-- ** mediaGetMimeType+    mediaGetMimeType                        ,+++-- ** mediaIsEmbedded+    mediaIsEmbedded                         ,+++-- ** mediaSave+    mediaSave                               ,+++-- ** mediaSaveToCallback+    mediaSaveToCallback                     ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Poppler.Types+import GI.Poppler.Callbacks+import qualified GI.GObject as GObject++newtype Media = Media (ForeignPtr Media)+foreign import ccall "poppler_media_get_type"+    c_poppler_media_get_type :: IO GType++type instance ParentTypes Media = MediaParentTypes+type MediaParentTypes = '[GObject.Object]++instance GObject Media where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_poppler_media_get_type+    ++class GObject o => MediaK o+instance (GObject o, IsDescendantOf Media o) => MediaK o++toMedia :: MediaK o => o -> IO Media+toMedia = unsafeCastTo Media++noMedia :: Maybe Media+noMedia = Nothing++type instance AttributeList Media = MediaAttributeList+type MediaAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList Media = MediaSignalList+type MediaSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method Media::get_filename+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Media", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Media", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "poppler_media_get_filename" poppler_media_get_filename :: +    Ptr Media ->                            -- _obj : TInterface "Poppler" "Media"+    IO CString+++mediaGetFilename ::+    (MonadIO m, MediaK a) =>+    a ->                                    -- _obj+    m T.Text+mediaGetFilename _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_media_get_filename _obj'+    checkUnexpectedReturnNULL "poppler_media_get_filename" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method Media::get_mime_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Media", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Media", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "poppler_media_get_mime_type" poppler_media_get_mime_type :: +    Ptr Media ->                            -- _obj : TInterface "Poppler" "Media"+    IO CString+++mediaGetMimeType ::+    (MonadIO m, MediaK a) =>+    a ->                                    -- _obj+    m T.Text+mediaGetMimeType _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_media_get_mime_type _obj'+    checkUnexpectedReturnNULL "poppler_media_get_mime_type" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method Media::is_embedded+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Media", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Media", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "poppler_media_is_embedded" poppler_media_is_embedded :: +    Ptr Media ->                            -- _obj : TInterface "Poppler" "Media"+    IO CInt+++mediaIsEmbedded ::+    (MonadIO m, MediaK a) =>+    a ->                                    -- _obj+    m Bool+mediaIsEmbedded _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_media_is_embedded _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Media::save+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Media", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "filename", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Media", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "filename", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "poppler_media_save" poppler_media_save :: +    Ptr Media ->                            -- _obj : TInterface "Poppler" "Media"+    CString ->                              -- filename : TBasicType TUTF8+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++mediaSave ::+    (MonadIO m, MediaK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- filename+    m ()+mediaSave _obj filename = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    filename' <- textToCString filename+    onException (do+        _ <- propagateGError $ poppler_media_save _obj' filename'+        touchManagedPtr _obj+        freeMem filename'+        return ()+     ) (do+        freeMem filename'+     )++-- method Media::save_to_callback+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Media", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "save_func", argType = TInterface "Poppler" "MediaSaveFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, transfer = TransferNothing},Arg {argName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Media", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "save_func", argType = TInterface "Poppler" "MediaSaveFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "poppler_media_save_to_callback" poppler_media_save_to_callback :: +    Ptr Media ->                            -- _obj : TInterface "Poppler" "Media"+    FunPtr MediaSaveFuncC ->                -- save_func : TInterface "Poppler" "MediaSaveFunc"+    Ptr () ->                               -- user_data : TBasicType TVoid+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++mediaSaveToCallback ::+    (MonadIO m, MediaK a) =>+    a ->                                    -- _obj+    MediaSaveFunc ->                        -- save_func+    m ()+mediaSaveToCallback _obj save_func = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    save_func' <- mkMediaSaveFunc (mediaSaveFuncWrapper Nothing save_func)+    let user_data = nullPtr+    onException (do+        _ <- propagateGError $ poppler_media_save_to_callback _obj' save_func' user_data+        safeFreeFunPtr $ castFunPtrToPtr save_func'+        touchManagedPtr _obj+        return ()+     ) (do+        safeFreeFunPtr $ castFunPtrToPtr save_func'+        return ()+     )++
+ GI/Poppler/Objects/Media.hs-boot view
@@ -0,0 +1,13 @@+module GI.Poppler.Objects.Media where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype Media = Media (ForeignPtr Media)+instance GObject Media where+class GObject o => MediaK o+instance (GObject o, IsDescendantOf Media o) => MediaK o
+ GI/Poppler/Objects/Movie.hs view
@@ -0,0 +1,149 @@++{- |+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.Movie+    ( ++-- * Exported types+    Movie(..)                               ,+    MovieK                                  ,+    toMovie                                 ,+    noMovie                                 ,+++ -- * Methods+-- ** movieGetFilename+    movieGetFilename                        ,+++-- ** movieNeedPoster+    movieNeedPoster                         ,+++-- ** movieShowControls+    movieShowControls                       ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Poppler.Types+import GI.Poppler.Callbacks+import qualified GI.GObject as GObject++newtype Movie = Movie (ForeignPtr Movie)+foreign import ccall "poppler_movie_get_type"+    c_poppler_movie_get_type :: IO GType++type instance ParentTypes Movie = MovieParentTypes+type MovieParentTypes = '[GObject.Object]++instance GObject Movie where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_poppler_movie_get_type+    ++class GObject o => MovieK o+instance (GObject o, IsDescendantOf Movie o) => MovieK o++toMovie :: MovieK o => o -> IO Movie+toMovie = unsafeCastTo Movie++noMovie :: Maybe Movie+noMovie = Nothing++type instance AttributeList Movie = MovieAttributeList+type MovieAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList Movie = MovieSignalList+type MovieSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method Movie::get_filename+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Movie", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Movie", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "poppler_movie_get_filename" poppler_movie_get_filename :: +    Ptr Movie ->                            -- _obj : TInterface "Poppler" "Movie"+    IO CString+++movieGetFilename ::+    (MonadIO m, MovieK a) =>+    a ->                                    -- _obj+    m T.Text+movieGetFilename _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_movie_get_filename _obj'+    checkUnexpectedReturnNULL "poppler_movie_get_filename" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method Movie::need_poster+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Movie", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Movie", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "poppler_movie_need_poster" poppler_movie_need_poster :: +    Ptr Movie ->                            -- _obj : TInterface "Poppler" "Movie"+    IO CInt+++movieNeedPoster ::+    (MonadIO m, MovieK a) =>+    a ->                                    -- _obj+    m Bool+movieNeedPoster _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_movie_need_poster _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method Movie::show_controls+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Movie", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Movie", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "poppler_movie_show_controls" poppler_movie_show_controls :: +    Ptr Movie ->                            -- _obj : TInterface "Poppler" "Movie"+    IO CInt+++movieShowControls ::+    (MonadIO m, MovieK a) =>+    a ->                                    -- _obj+    m Bool+movieShowControls _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_movie_show_controls _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++
+ GI/Poppler/Objects/Movie.hs-boot view
@@ -0,0 +1,13 @@+module GI.Poppler.Objects.Movie where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype Movie = Movie (ForeignPtr Movie)+instance GObject Movie where+class GObject o => MovieK o+instance (GObject o, IsDescendantOf Movie o) => MovieK o
+ GI/Poppler/Objects/PSFile.hs view
@@ -0,0 +1,192 @@++{- |+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.PSFile+    ( ++-- * Exported types+    PSFile(..)                              ,+    PSFileK                                 ,+    toPSFile                                ,+    noPSFile                                ,+++ -- * Methods+-- ** pSFileFree+    pSFileFree                              ,+++-- ** pSFileNew+    pSFileNew                               ,+++-- ** pSFileSetDuplex+    pSFileSetDuplex                         ,+++-- ** pSFileSetPaperSize+    pSFileSetPaperSize                      ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Poppler.Types+import GI.Poppler.Callbacks+import qualified GI.GObject as GObject++newtype PSFile = PSFile (ForeignPtr PSFile)+foreign import ccall "poppler_ps_file_get_type"+    c_poppler_ps_file_get_type :: IO GType++type instance ParentTypes PSFile = PSFileParentTypes+type PSFileParentTypes = '[GObject.Object]++instance GObject PSFile where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_poppler_ps_file_get_type+    ++class GObject o => PSFileK o+instance (GObject o, IsDescendantOf PSFile o) => PSFileK o++toPSFile :: PSFileK o => o -> IO PSFile+toPSFile = unsafeCastTo PSFile++noPSFile :: Maybe PSFile+noPSFile = Nothing++type instance AttributeList PSFile = PSFileAttributeList+type PSFileAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList PSFile = PSFileSignalList+type PSFileSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method PSFile::new+-- method type : Constructor+-- Args : [Arg {argName = "document", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "filename", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "first_page", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_pages", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "document", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "filename", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "first_page", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_pages", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "PSFile"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_ps_file_new" poppler_ps_file_new :: +    Ptr Document ->                         -- document : TInterface "Poppler" "Document"+    CString ->                              -- filename : TBasicType TUTF8+    Int32 ->                                -- first_page : TBasicType TInt32+    Int32 ->                                -- n_pages : TBasicType TInt32+    IO (Ptr PSFile)+++pSFileNew ::+    (MonadIO m, DocumentK a) =>+    a ->                                    -- document+    T.Text ->                               -- filename+    Int32 ->                                -- first_page+    Int32 ->                                -- n_pages+    m PSFile+pSFileNew document filename first_page n_pages = liftIO $ do+    let document' = unsafeManagedPtrCastPtr document+    filename' <- textToCString filename+    result <- poppler_ps_file_new document' filename' first_page n_pages+    checkUnexpectedReturnNULL "poppler_ps_file_new" result+    result' <- (wrapObject PSFile) result+    touchManagedPtr document+    freeMem filename'+    return result'++-- method PSFile::free+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "PSFile", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "PSFile", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_ps_file_free" poppler_ps_file_free :: +    Ptr PSFile ->                           -- _obj : TInterface "Poppler" "PSFile"+    IO ()+++pSFileFree ::+    (MonadIO m, PSFileK a) =>+    a ->                                    -- _obj+    m ()+pSFileFree _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    poppler_ps_file_free _obj'+    touchManagedPtr _obj+    return ()++-- method PSFile::set_duplex+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "PSFile", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "duplex", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "PSFile", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "duplex", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_ps_file_set_duplex" poppler_ps_file_set_duplex :: +    Ptr PSFile ->                           -- _obj : TInterface "Poppler" "PSFile"+    CInt ->                                 -- duplex : TBasicType TBoolean+    IO ()+++pSFileSetDuplex ::+    (MonadIO m, PSFileK a) =>+    a ->                                    -- _obj+    Bool ->                                 -- duplex+    m ()+pSFileSetDuplex _obj duplex = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let duplex' = (fromIntegral . fromEnum) duplex+    poppler_ps_file_set_duplex _obj' duplex'+    touchManagedPtr _obj+    return ()++-- method PSFile::set_paper_size+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "PSFile", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "PSFile", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "height", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_ps_file_set_paper_size" poppler_ps_file_set_paper_size :: +    Ptr PSFile ->                           -- _obj : TInterface "Poppler" "PSFile"+    CDouble ->                              -- width : TBasicType TDouble+    CDouble ->                              -- height : TBasicType TDouble+    IO ()+++pSFileSetPaperSize ::+    (MonadIO m, PSFileK a) =>+    a ->                                    -- _obj+    Double ->                               -- width+    Double ->                               -- height+    m ()+pSFileSetPaperSize _obj width height = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let width' = realToFrac width+    let height' = realToFrac height+    poppler_ps_file_set_paper_size _obj' width' height'+    touchManagedPtr _obj+    return ()++
+ GI/Poppler/Objects/PSFile.hs-boot view
@@ -0,0 +1,13 @@+module GI.Poppler.Objects.PSFile where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype PSFile = PSFile (ForeignPtr PSFile)+instance GObject PSFile where+class GObject o => PSFileK o+instance (GObject o, IsDescendantOf PSFile o) => PSFileK o
+ GI/Poppler/Objects/Page.hs view
@@ -0,0 +1,1341 @@++{- |+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.Page+    ( ++-- * Exported types+    Page(..)                                ,+    PageK                                   ,+    toPage                                  ,+    noPage                                  ,+++ -- * Methods+-- ** pageAddAnnot+    pageAddAnnot                            ,+++-- ** pageFindText+    pageFindText                            ,+++-- ** pageFindTextWithOptions+    pageFindTextWithOptions                 ,+++-- ** pageFreeAnnotMapping+    pageFreeAnnotMapping                    ,+++-- ** pageFreeFormFieldMapping+    pageFreeFormFieldMapping                ,+++-- ** pageFreeImageMapping+    pageFreeImageMapping                    ,+++-- ** pageFreeLinkMapping+    pageFreeLinkMapping                     ,+++-- ** pageFreeTextAttributes+    pageFreeTextAttributes                  ,+++-- ** pageGetAnnotMapping+    pageGetAnnotMapping                     ,+++-- ** pageGetCropBox+    pageGetCropBox                          ,+++-- ** pageGetDuration+    pageGetDuration                         ,+++-- ** pageGetFormFieldMapping+    pageGetFormFieldMapping                 ,+++-- ** pageGetImage+    pageGetImage                            ,+++-- ** pageGetImageMapping+    pageGetImageMapping                     ,+++-- ** pageGetIndex+    pageGetIndex                            ,+++-- ** pageGetLabel+    pageGetLabel                            ,+++-- ** pageGetLinkMapping+    pageGetLinkMapping                      ,+++-- ** pageGetSelectedRegion+    pageGetSelectedRegion                   ,+++-- ** pageGetSelectedText+    pageGetSelectedText                     ,+++-- ** pageGetSelectionRegion+    pageGetSelectionRegion                  ,+++-- ** pageGetSize+    pageGetSize                             ,+++-- ** pageGetText+    pageGetText                             ,+++-- ** pageGetTextAttributes+    pageGetTextAttributes                   ,+++-- ** pageGetTextAttributesForArea+    pageGetTextAttributesForArea            ,+++-- ** pageGetTextForArea+    pageGetTextForArea                      ,+++-- ** pageGetTextLayout+    pageGetTextLayout                       ,+++-- ** pageGetTextLayoutForArea+    pageGetTextLayoutForArea                ,+++-- ** pageGetThumbnail+    pageGetThumbnail                        ,+++-- ** pageGetThumbnailSize+    pageGetThumbnailSize                    ,+++-- ** pageGetTransition+    pageGetTransition                       ,+++-- ** pageRemoveAnnot+    pageRemoveAnnot                         ,+++-- ** pageRender+    pageRender                              ,+++-- ** pageRenderForPrinting+    pageRenderForPrinting                   ,+++-- ** pageRenderForPrintingWithOptions+    pageRenderForPrintingWithOptions        ,+++-- ** pageRenderSelection+    pageRenderSelection                     ,+++-- ** pageRenderToPs+    pageRenderToPs                          ,+++-- ** pageSelectionRegionFree+    pageSelectionRegionFree                 ,+++++ -- * Properties+-- ** Label+    PageLabelPropertyInfo                   ,+    getPageLabel                            ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Poppler.Types+import GI.Poppler.Callbacks+import qualified GI.GObject as GObject+import qualified GI.Cairo as Cairo++newtype Page = Page (ForeignPtr Page)+foreign import ccall "poppler_page_get_type"+    c_poppler_page_get_type :: IO GType++type instance ParentTypes Page = PageParentTypes+type PageParentTypes = '[GObject.Object]++instance GObject Page where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_poppler_page_get_type+    ++class GObject o => PageK o+instance (GObject o, IsDescendantOf Page o) => PageK o++toPage :: PageK o => o -> IO Page+toPage = unsafeCastTo Page++noPage :: Maybe Page+noPage = Nothing++-- VVV Prop "label"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable]++getPageLabel :: (MonadIO m, PageK o) => o -> m T.Text+getPageLabel obj = liftIO $ getObjectPropertyString obj "label"++data PageLabelPropertyInfo+instance AttrInfo PageLabelPropertyInfo where+    type AttrAllowedOps PageLabelPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint PageLabelPropertyInfo = (~) ()+    type AttrBaseTypeConstraint PageLabelPropertyInfo = PageK+    type AttrGetType PageLabelPropertyInfo = T.Text+    type AttrLabel PageLabelPropertyInfo = "Page::label"+    attrGet _ = getPageLabel+    attrSet _ = undefined+    attrConstruct _ = undefined++type instance AttributeList Page = PageAttributeList+type PageAttributeList = ('[ '("label", PageLabelPropertyInfo)] :: [(Symbol, *)])++type instance SignalList Page = PageSignalList+type PageSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method Page::add_annot+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Page", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "annot", argType = TInterface "Poppler" "Annot", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Page", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "annot", argType = TInterface "Poppler" "Annot", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_page_add_annot" poppler_page_add_annot :: +    Ptr Page ->                             -- _obj : TInterface "Poppler" "Page"+    Ptr Annot ->                            -- annot : TInterface "Poppler" "Annot"+    IO ()+++pageAddAnnot ::+    (MonadIO m, PageK a, AnnotK b) =>+    a ->                                    -- _obj+    b ->                                    -- annot+    m ()+pageAddAnnot _obj annot = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let annot' = unsafeManagedPtrCastPtr annot+    poppler_page_add_annot _obj' annot'+    touchManagedPtr _obj+    touchManagedPtr annot+    return ()++-- method Page::find_text+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Page", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Page", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGList (TInterface "Poppler" "Rectangle")+-- throws : False+-- Skip return : False++foreign import ccall "poppler_page_find_text" poppler_page_find_text :: +    Ptr Page ->                             -- _obj : TInterface "Poppler" "Page"+    CString ->                              -- text : TBasicType TUTF8+    IO (Ptr (GList (Ptr Rectangle)))+++pageFindText ::+    (MonadIO m, PageK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- text+    m [Rectangle]+pageFindText _obj text = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    text' <- textToCString text+    result <- poppler_page_find_text _obj' text'+    checkUnexpectedReturnNULL "poppler_page_find_text" result+    result' <- unpackGList result+    result'' <- mapM (wrapBoxed Rectangle) result'+    g_list_free result+    touchManagedPtr _obj+    freeMem text'+    return result''++-- method Page::find_text_with_options+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Page", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "options", argType = TInterface "Poppler" "FindFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Page", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "options", argType = TInterface "Poppler" "FindFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGList (TInterface "Poppler" "Rectangle")+-- throws : False+-- Skip return : False++foreign import ccall "poppler_page_find_text_with_options" poppler_page_find_text_with_options :: +    Ptr Page ->                             -- _obj : TInterface "Poppler" "Page"+    CString ->                              -- text : TBasicType TUTF8+    CUInt ->                                -- options : TInterface "Poppler" "FindFlags"+    IO (Ptr (GList (Ptr Rectangle)))+++pageFindTextWithOptions ::+    (MonadIO m, PageK a) =>+    a ->                                    -- _obj+    T.Text ->                               -- text+    [FindFlags] ->                          -- options+    m [Rectangle]+pageFindTextWithOptions _obj text options = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    text' <- textToCString text+    let options' = gflagsToWord options+    result <- poppler_page_find_text_with_options _obj' text' options'+    checkUnexpectedReturnNULL "poppler_page_find_text_with_options" result+    result' <- unpackGList result+    result'' <- mapM (wrapBoxed Rectangle) result'+    g_list_free result+    touchManagedPtr _obj+    freeMem text'+    return result''++-- method Page::get_annot_mapping+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Page", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Page", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGList (TInterface "Poppler" "AnnotMapping")+-- throws : False+-- Skip return : False++foreign import ccall "poppler_page_get_annot_mapping" poppler_page_get_annot_mapping :: +    Ptr Page ->                             -- _obj : TInterface "Poppler" "Page"+    IO (Ptr (GList (Ptr AnnotMapping)))+++pageGetAnnotMapping ::+    (MonadIO m, PageK a) =>+    a ->                                    -- _obj+    m [AnnotMapping]+pageGetAnnotMapping _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_page_get_annot_mapping _obj'+    checkUnexpectedReturnNULL "poppler_page_get_annot_mapping" result+    result' <- unpackGList result+    result'' <- mapM (wrapBoxed AnnotMapping) result'+    g_list_free result+    touchManagedPtr _obj+    return result''++-- method Page::get_crop_box+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Page", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "rect", argType = TInterface "Poppler" "Rectangle", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Page", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_page_get_crop_box" poppler_page_get_crop_box :: +    Ptr Page ->                             -- _obj : TInterface "Poppler" "Page"+    Ptr Rectangle ->                        -- rect : TInterface "Poppler" "Rectangle"+    IO ()+++pageGetCropBox ::+    (MonadIO m, PageK a) =>+    a ->                                    -- _obj+    m (Rectangle)+pageGetCropBox _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    rect <- callocBoxedBytes 32 :: IO (Ptr Rectangle)+    poppler_page_get_crop_box _obj' rect+    rect' <- (wrapBoxed Rectangle) rect+    touchManagedPtr _obj+    return rect'++-- method Page::get_duration+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Page", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Page", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TDouble+-- throws : False+-- Skip return : False++foreign import ccall "poppler_page_get_duration" poppler_page_get_duration :: +    Ptr Page ->                             -- _obj : TInterface "Poppler" "Page"+    IO CDouble+++pageGetDuration ::+    (MonadIO m, PageK a) =>+    a ->                                    -- _obj+    m Double+pageGetDuration _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_page_get_duration _obj'+    let result' = realToFrac result+    touchManagedPtr _obj+    return result'++-- method Page::get_form_field_mapping+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Page", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Page", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGList (TInterface "Poppler" "FormFieldMapping")+-- throws : False+-- Skip return : False++foreign import ccall "poppler_page_get_form_field_mapping" poppler_page_get_form_field_mapping :: +    Ptr Page ->                             -- _obj : TInterface "Poppler" "Page"+    IO (Ptr (GList (Ptr FormFieldMapping)))+++pageGetFormFieldMapping ::+    (MonadIO m, PageK a) =>+    a ->                                    -- _obj+    m [FormFieldMapping]+pageGetFormFieldMapping _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_page_get_form_field_mapping _obj'+    checkUnexpectedReturnNULL "poppler_page_get_form_field_mapping" result+    result' <- unpackGList result+    result'' <- mapM (wrapBoxed FormFieldMapping) result'+    g_list_free result+    touchManagedPtr _obj+    return result''++-- method Page::get_image+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Page", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "image_id", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Page", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "image_id", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "cairo" "Surface"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_page_get_image" poppler_page_get_image :: +    Ptr Page ->                             -- _obj : TInterface "Poppler" "Page"+    Int32 ->                                -- image_id : TBasicType TInt32+    IO (Ptr Cairo.Surface)+++pageGetImage ::+    (MonadIO m, PageK a) =>+    a ->                                    -- _obj+    Int32 ->                                -- image_id+    m Cairo.Surface+pageGetImage _obj image_id = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_page_get_image _obj' image_id+    checkUnexpectedReturnNULL "poppler_page_get_image" result+    result' <- (wrapBoxed Cairo.Surface) result+    touchManagedPtr _obj+    return result'++-- method Page::get_image_mapping+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Page", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Page", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGList (TInterface "Poppler" "ImageMapping")+-- throws : False+-- Skip return : False++foreign import ccall "poppler_page_get_image_mapping" poppler_page_get_image_mapping :: +    Ptr Page ->                             -- _obj : TInterface "Poppler" "Page"+    IO (Ptr (GList (Ptr ImageMapping)))+++pageGetImageMapping ::+    (MonadIO m, PageK a) =>+    a ->                                    -- _obj+    m [ImageMapping]+pageGetImageMapping _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_page_get_image_mapping _obj'+    checkUnexpectedReturnNULL "poppler_page_get_image_mapping" result+    result' <- unpackGList result+    result'' <- mapM (wrapBoxed ImageMapping) result'+    g_list_free result+    touchManagedPtr _obj+    return result''++-- method Page::get_index+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Page", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Page", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "poppler_page_get_index" poppler_page_get_index :: +    Ptr Page ->                             -- _obj : TInterface "Poppler" "Page"+    IO Int32+++pageGetIndex ::+    (MonadIO m, PageK a) =>+    a ->                                    -- _obj+    m Int32+pageGetIndex _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_page_get_index _obj'+    touchManagedPtr _obj+    return result++-- method Page::get_label+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Page", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Page", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "poppler_page_get_label" poppler_page_get_label :: +    Ptr Page ->                             -- _obj : TInterface "Poppler" "Page"+    IO CString+++pageGetLabel ::+    (MonadIO m, PageK a) =>+    a ->                                    -- _obj+    m T.Text+pageGetLabel _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_page_get_label _obj'+    checkUnexpectedReturnNULL "poppler_page_get_label" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method Page::get_link_mapping+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Page", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Page", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGList (TInterface "Poppler" "LinkMapping")+-- throws : False+-- Skip return : False++foreign import ccall "poppler_page_get_link_mapping" poppler_page_get_link_mapping :: +    Ptr Page ->                             -- _obj : TInterface "Poppler" "Page"+    IO (Ptr (GList (Ptr LinkMapping)))+++pageGetLinkMapping ::+    (MonadIO m, PageK a) =>+    a ->                                    -- _obj+    m [LinkMapping]+pageGetLinkMapping _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_page_get_link_mapping _obj'+    checkUnexpectedReturnNULL "poppler_page_get_link_mapping" result+    result' <- unpackGList result+    result'' <- mapM (wrapBoxed LinkMapping) result'+    g_list_free result+    touchManagedPtr _obj+    return result''++-- method Page::get_selected_region+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Page", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "scale", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "style", argType = TInterface "Poppler" "SelectionStyle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "selection", argType = TInterface "Poppler" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Page", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "scale", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "style", argType = TInterface "Poppler" "SelectionStyle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "selection", argType = TInterface "Poppler" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "cairo" "Region"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_page_get_selected_region" poppler_page_get_selected_region :: +    Ptr Page ->                             -- _obj : TInterface "Poppler" "Page"+    CDouble ->                              -- scale : TBasicType TDouble+    CUInt ->                                -- style : TInterface "Poppler" "SelectionStyle"+    Ptr Rectangle ->                        -- selection : TInterface "Poppler" "Rectangle"+    IO (Ptr Cairo.Region)+++pageGetSelectedRegion ::+    (MonadIO m, PageK a) =>+    a ->                                    -- _obj+    Double ->                               -- scale+    SelectionStyle ->                       -- style+    Rectangle ->                            -- selection+    m Cairo.Region+pageGetSelectedRegion _obj scale style selection = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let scale' = realToFrac scale+    let style' = (fromIntegral . fromEnum) style+    let selection' = unsafeManagedPtrGetPtr selection+    result <- poppler_page_get_selected_region _obj' scale' style' selection'+    checkUnexpectedReturnNULL "poppler_page_get_selected_region" result+    result' <- (wrapBoxed Cairo.Region) result+    touchManagedPtr _obj+    touchManagedPtr selection+    return result'++-- method Page::get_selected_text+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Page", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "style", argType = TInterface "Poppler" "SelectionStyle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "selection", argType = TInterface "Poppler" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Page", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "style", argType = TInterface "Poppler" "SelectionStyle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "selection", argType = TInterface "Poppler" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "poppler_page_get_selected_text" poppler_page_get_selected_text :: +    Ptr Page ->                             -- _obj : TInterface "Poppler" "Page"+    CUInt ->                                -- style : TInterface "Poppler" "SelectionStyle"+    Ptr Rectangle ->                        -- selection : TInterface "Poppler" "Rectangle"+    IO CString+++pageGetSelectedText ::+    (MonadIO m, PageK a) =>+    a ->                                    -- _obj+    SelectionStyle ->                       -- style+    Rectangle ->                            -- selection+    m T.Text+pageGetSelectedText _obj style selection = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let style' = (fromIntegral . fromEnum) style+    let selection' = unsafeManagedPtrGetPtr selection+    result <- poppler_page_get_selected_text _obj' style' selection'+    checkUnexpectedReturnNULL "poppler_page_get_selected_text" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    touchManagedPtr selection+    return result'++-- method Page::get_selection_region+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Page", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "scale", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "style", argType = TInterface "Poppler" "SelectionStyle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "selection", argType = TInterface "Poppler" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Page", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "scale", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "style", argType = TInterface "Poppler" "SelectionStyle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "selection", argType = TInterface "Poppler" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGList (TInterface "Poppler" "Rectangle")+-- throws : False+-- Skip return : False++foreign import ccall "poppler_page_get_selection_region" poppler_page_get_selection_region :: +    Ptr Page ->                             -- _obj : TInterface "Poppler" "Page"+    CDouble ->                              -- scale : TBasicType TDouble+    CUInt ->                                -- style : TInterface "Poppler" "SelectionStyle"+    Ptr Rectangle ->                        -- selection : TInterface "Poppler" "Rectangle"+    IO (Ptr (GList (Ptr Rectangle)))++{-# DEPRECATED pageGetSelectionRegion ["(Since version 0.16)","Use poppler_page_get_selected_region() instead."]#-}+pageGetSelectionRegion ::+    (MonadIO m, PageK a) =>+    a ->                                    -- _obj+    Double ->                               -- scale+    SelectionStyle ->                       -- style+    Rectangle ->                            -- selection+    m [Rectangle]+pageGetSelectionRegion _obj scale style selection = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let scale' = realToFrac scale+    let style' = (fromIntegral . fromEnum) style+    let selection' = unsafeManagedPtrGetPtr selection+    result <- poppler_page_get_selection_region _obj' scale' style' selection'+    checkUnexpectedReturnNULL "poppler_page_get_selection_region" result+    result' <- unpackGList result+    result'' <- mapM (wrapBoxed Rectangle) result'+    g_list_free result+    touchManagedPtr _obj+    touchManagedPtr selection+    return result''++-- method Page::get_size+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Page", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "height", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Page", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_page_get_size" poppler_page_get_size :: +    Ptr Page ->                             -- _obj : TInterface "Poppler" "Page"+    Ptr CDouble ->                          -- width : TBasicType TDouble+    Ptr CDouble ->                          -- height : TBasicType TDouble+    IO ()+++pageGetSize ::+    (MonadIO m, PageK a) =>+    a ->                                    -- _obj+    m (Double,Double)+pageGetSize _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    width <- allocMem :: IO (Ptr CDouble)+    height <- allocMem :: IO (Ptr CDouble)+    poppler_page_get_size _obj' width height+    width' <- peek width+    let width'' = realToFrac width'+    height' <- peek height+    let height'' = realToFrac height'+    touchManagedPtr _obj+    freeMem width+    freeMem height+    return (width'', height'')++-- method Page::get_text+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Page", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Page", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "poppler_page_get_text" poppler_page_get_text :: +    Ptr Page ->                             -- _obj : TInterface "Poppler" "Page"+    IO CString+++pageGetText ::+    (MonadIO m, PageK a) =>+    a ->                                    -- _obj+    m T.Text+pageGetText _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_page_get_text _obj'+    checkUnexpectedReturnNULL "poppler_page_get_text" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method Page::get_text_attributes+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Page", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Page", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGList (TInterface "Poppler" "TextAttributes")+-- throws : False+-- Skip return : False++foreign import ccall "poppler_page_get_text_attributes" poppler_page_get_text_attributes :: +    Ptr Page ->                             -- _obj : TInterface "Poppler" "Page"+    IO (Ptr (GList (Ptr TextAttributes)))+++pageGetTextAttributes ::+    (MonadIO m, PageK a) =>+    a ->                                    -- _obj+    m [TextAttributes]+pageGetTextAttributes _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_page_get_text_attributes _obj'+    checkUnexpectedReturnNULL "poppler_page_get_text_attributes" result+    result' <- unpackGList result+    result'' <- mapM (wrapBoxed TextAttributes) result'+    g_list_free result+    touchManagedPtr _obj+    return result''++-- method Page::get_text_attributes_for_area+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Page", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "area", argType = TInterface "Poppler" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Page", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "area", argType = TInterface "Poppler" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TGList (TInterface "Poppler" "TextAttributes")+-- throws : False+-- Skip return : False++foreign import ccall "poppler_page_get_text_attributes_for_area" poppler_page_get_text_attributes_for_area :: +    Ptr Page ->                             -- _obj : TInterface "Poppler" "Page"+    Ptr Rectangle ->                        -- area : TInterface "Poppler" "Rectangle"+    IO (Ptr (GList (Ptr TextAttributes)))+++pageGetTextAttributesForArea ::+    (MonadIO m, PageK a) =>+    a ->                                    -- _obj+    Rectangle ->                            -- area+    m [TextAttributes]+pageGetTextAttributesForArea _obj area = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let area' = unsafeManagedPtrGetPtr area+    result <- poppler_page_get_text_attributes_for_area _obj' area'+    checkUnexpectedReturnNULL "poppler_page_get_text_attributes_for_area" result+    result' <- unpackGList result+    result'' <- mapM (wrapBoxed TextAttributes) result'+    g_list_free result+    touchManagedPtr _obj+    touchManagedPtr area+    return result''++-- method Page::get_text_for_area+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Page", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "area", argType = TInterface "Poppler" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Page", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "area", argType = TInterface "Poppler" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "poppler_page_get_text_for_area" poppler_page_get_text_for_area :: +    Ptr Page ->                             -- _obj : TInterface "Poppler" "Page"+    Ptr Rectangle ->                        -- area : TInterface "Poppler" "Rectangle"+    IO CString+++pageGetTextForArea ::+    (MonadIO m, PageK a) =>+    a ->                                    -- _obj+    Rectangle ->                            -- area+    m T.Text+pageGetTextForArea _obj area = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let area' = unsafeManagedPtrGetPtr area+    result <- poppler_page_get_text_for_area _obj' area'+    checkUnexpectedReturnNULL "poppler_page_get_text_for_area" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    touchManagedPtr area+    return result'++-- method Page::get_text_layout+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Page", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "rectangles", argType = TCArray False (-1) 2 (TInterface "Poppler" "Rectangle"), direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferContainer},Arg {argName = "n_rectangles", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : [Arg {argName = "n_rectangles", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Page", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "poppler_page_get_text_layout" poppler_page_get_text_layout :: +    Ptr Page ->                             -- _obj : TInterface "Poppler" "Page"+    Ptr (Ptr Rectangle) ->                  -- rectangles : TCArray False (-1) 2 (TInterface "Poppler" "Rectangle")+    Ptr Word32 ->                           -- n_rectangles : TBasicType TUInt32+    IO CInt+++pageGetTextLayout ::+    (MonadIO m, PageK a) =>+    a ->                                    -- _obj+    m (Bool,[Rectangle])+pageGetTextLayout _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    rectangles <- allocMem :: IO (Ptr (Ptr Rectangle))+    n_rectangles <- allocMem :: IO (Ptr Word32)+    result <- poppler_page_get_text_layout _obj' rectangles n_rectangles+    n_rectangles' <- peek n_rectangles+    let result' = (/= 0) result+    rectangles' <- peek rectangles+    rectangles'' <- (unpackBoxedArrayWithLength 32 n_rectangles') rectangles'+    rectangles''' <- mapM (newBoxed Rectangle) rectangles''+    freeMem rectangles'+    touchManagedPtr _obj+    freeMem rectangles+    freeMem n_rectangles+    return (result', rectangles''')++-- method Page::get_text_layout_for_area+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Page", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "area", argType = TInterface "Poppler" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "rectangles", argType = TCArray False (-1) 3 (TInterface "Poppler" "Rectangle"), direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferContainer},Arg {argName = "n_rectangles", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : [Arg {argName = "n_rectangles", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Page", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "area", argType = TInterface "Poppler" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "poppler_page_get_text_layout_for_area" poppler_page_get_text_layout_for_area :: +    Ptr Page ->                             -- _obj : TInterface "Poppler" "Page"+    Ptr Rectangle ->                        -- area : TInterface "Poppler" "Rectangle"+    Ptr (Ptr Rectangle) ->                  -- rectangles : TCArray False (-1) 3 (TInterface "Poppler" "Rectangle")+    Ptr Word32 ->                           -- n_rectangles : TBasicType TUInt32+    IO CInt+++pageGetTextLayoutForArea ::+    (MonadIO m, PageK a) =>+    a ->                                    -- _obj+    Rectangle ->                            -- area+    m (Bool,[Rectangle])+pageGetTextLayoutForArea _obj area = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let area' = unsafeManagedPtrGetPtr area+    rectangles <- allocMem :: IO (Ptr (Ptr Rectangle))+    n_rectangles <- allocMem :: IO (Ptr Word32)+    result <- poppler_page_get_text_layout_for_area _obj' area' rectangles n_rectangles+    n_rectangles' <- peek n_rectangles+    let result' = (/= 0) result+    rectangles' <- peek rectangles+    rectangles'' <- (unpackBoxedArrayWithLength 32 n_rectangles') rectangles'+    rectangles''' <- mapM (newBoxed Rectangle) rectangles''+    freeMem rectangles'+    touchManagedPtr _obj+    touchManagedPtr area+    freeMem rectangles+    freeMem n_rectangles+    return (result', rectangles''')++-- method Page::get_thumbnail+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Page", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Page", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "cairo" "Surface"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_page_get_thumbnail" poppler_page_get_thumbnail :: +    Ptr Page ->                             -- _obj : TInterface "Poppler" "Page"+    IO (Ptr Cairo.Surface)+++pageGetThumbnail ::+    (MonadIO m, PageK a) =>+    a ->                                    -- _obj+    m Cairo.Surface+pageGetThumbnail _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_page_get_thumbnail _obj'+    checkUnexpectedReturnNULL "poppler_page_get_thumbnail" result+    result' <- (wrapBoxed Cairo.Surface) result+    touchManagedPtr _obj+    return result'++-- method Page::get_thumbnail_size+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Page", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "width", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything},Arg {argName = "height", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Page", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "poppler_page_get_thumbnail_size" poppler_page_get_thumbnail_size :: +    Ptr Page ->                             -- _obj : TInterface "Poppler" "Page"+    Ptr Int32 ->                            -- width : TBasicType TInt32+    Ptr Int32 ->                            -- height : TBasicType TInt32+    IO CInt+++pageGetThumbnailSize ::+    (MonadIO m, PageK a) =>+    a ->                                    -- _obj+    m (Bool,Int32,Int32)+pageGetThumbnailSize _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    width <- allocMem :: IO (Ptr Int32)+    height <- allocMem :: IO (Ptr Int32)+    result <- poppler_page_get_thumbnail_size _obj' width height+    let result' = (/= 0) result+    width' <- peek width+    height' <- peek height+    touchManagedPtr _obj+    freeMem width+    freeMem height+    return (result', width', height')++-- method Page::get_transition+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Page", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Page", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "PageTransition"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_page_get_transition" poppler_page_get_transition :: +    Ptr Page ->                             -- _obj : TInterface "Poppler" "Page"+    IO (Ptr PageTransition)+++pageGetTransition ::+    (MonadIO m, PageK a) =>+    a ->                                    -- _obj+    m PageTransition+pageGetTransition _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_page_get_transition _obj'+    checkUnexpectedReturnNULL "poppler_page_get_transition" result+    result' <- (wrapBoxed PageTransition) result+    touchManagedPtr _obj+    return result'++-- method Page::remove_annot+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Page", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "annot", argType = TInterface "Poppler" "Annot", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Page", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "annot", argType = TInterface "Poppler" "Annot", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_page_remove_annot" poppler_page_remove_annot :: +    Ptr Page ->                             -- _obj : TInterface "Poppler" "Page"+    Ptr Annot ->                            -- annot : TInterface "Poppler" "Annot"+    IO ()+++pageRemoveAnnot ::+    (MonadIO m, PageK a, AnnotK b) =>+    a ->                                    -- _obj+    b ->                                    -- annot+    m ()+pageRemoveAnnot _obj annot = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let annot' = unsafeManagedPtrCastPtr annot+    poppler_page_remove_annot _obj' annot'+    touchManagedPtr _obj+    touchManagedPtr annot+    return ()++-- method Page::render+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Page", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cairo", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Page", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cairo", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_page_render" poppler_page_render :: +    Ptr Page ->                             -- _obj : TInterface "Poppler" "Page"+    Ptr Cairo.Context ->                    -- cairo : TInterface "cairo" "Context"+    IO ()+++pageRender ::+    (MonadIO m, PageK a) =>+    a ->                                    -- _obj+    Cairo.Context ->                        -- cairo+    m ()+pageRender _obj cairo = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let cairo' = unsafeManagedPtrGetPtr cairo+    poppler_page_render _obj' cairo'+    touchManagedPtr _obj+    touchManagedPtr cairo+    return ()++-- method Page::render_for_printing+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Page", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cairo", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Page", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cairo", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_page_render_for_printing" poppler_page_render_for_printing :: +    Ptr Page ->                             -- _obj : TInterface "Poppler" "Page"+    Ptr Cairo.Context ->                    -- cairo : TInterface "cairo" "Context"+    IO ()+++pageRenderForPrinting ::+    (MonadIO m, PageK a) =>+    a ->                                    -- _obj+    Cairo.Context ->                        -- cairo+    m ()+pageRenderForPrinting _obj cairo = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let cairo' = unsafeManagedPtrGetPtr cairo+    poppler_page_render_for_printing _obj' cairo'+    touchManagedPtr _obj+    touchManagedPtr cairo+    return ()++-- method Page::render_for_printing_with_options+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Page", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cairo", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "options", argType = TInterface "Poppler" "PrintFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Page", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cairo", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "options", argType = TInterface "Poppler" "PrintFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_page_render_for_printing_with_options" poppler_page_render_for_printing_with_options :: +    Ptr Page ->                             -- _obj : TInterface "Poppler" "Page"+    Ptr Cairo.Context ->                    -- cairo : TInterface "cairo" "Context"+    CUInt ->                                -- options : TInterface "Poppler" "PrintFlags"+    IO ()+++pageRenderForPrintingWithOptions ::+    (MonadIO m, PageK a) =>+    a ->                                    -- _obj+    Cairo.Context ->                        -- cairo+    [PrintFlags] ->                         -- options+    m ()+pageRenderForPrintingWithOptions _obj cairo options = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let cairo' = unsafeManagedPtrGetPtr cairo+    let options' = gflagsToWord options+    poppler_page_render_for_printing_with_options _obj' cairo' options'+    touchManagedPtr _obj+    touchManagedPtr cairo+    return ()++-- method Page::render_selection+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Page", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cairo", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "selection", argType = TInterface "Poppler" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "old_selection", argType = TInterface "Poppler" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "style", argType = TInterface "Poppler" "SelectionStyle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "glyph_color", argType = TInterface "Poppler" "Color", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "background_color", argType = TInterface "Poppler" "Color", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Page", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "cairo", argType = TInterface "cairo" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "selection", argType = TInterface "Poppler" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "old_selection", argType = TInterface "Poppler" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "style", argType = TInterface "Poppler" "SelectionStyle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "glyph_color", argType = TInterface "Poppler" "Color", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "background_color", argType = TInterface "Poppler" "Color", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_page_render_selection" poppler_page_render_selection :: +    Ptr Page ->                             -- _obj : TInterface "Poppler" "Page"+    Ptr Cairo.Context ->                    -- cairo : TInterface "cairo" "Context"+    Ptr Rectangle ->                        -- selection : TInterface "Poppler" "Rectangle"+    Ptr Rectangle ->                        -- old_selection : TInterface "Poppler" "Rectangle"+    CUInt ->                                -- style : TInterface "Poppler" "SelectionStyle"+    Ptr Color ->                            -- glyph_color : TInterface "Poppler" "Color"+    Ptr Color ->                            -- background_color : TInterface "Poppler" "Color"+    IO ()+++pageRenderSelection ::+    (MonadIO m, PageK a) =>+    a ->                                    -- _obj+    Cairo.Context ->                        -- cairo+    Rectangle ->                            -- selection+    Rectangle ->                            -- old_selection+    SelectionStyle ->                       -- style+    Color ->                                -- glyph_color+    Color ->                                -- background_color+    m ()+pageRenderSelection _obj cairo selection old_selection style glyph_color background_color = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let cairo' = unsafeManagedPtrGetPtr cairo+    let selection' = unsafeManagedPtrGetPtr selection+    let old_selection' = unsafeManagedPtrGetPtr old_selection+    let style' = (fromIntegral . fromEnum) style+    let glyph_color' = unsafeManagedPtrGetPtr glyph_color+    let background_color' = unsafeManagedPtrGetPtr background_color+    poppler_page_render_selection _obj' cairo' selection' old_selection' style' glyph_color' background_color'+    touchManagedPtr _obj+    touchManagedPtr cairo+    touchManagedPtr selection+    touchManagedPtr old_selection+    touchManagedPtr glyph_color+    touchManagedPtr background_color+    return ()++-- method Page::render_to_ps+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Page", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "ps_file", argType = TInterface "Poppler" "PSFile", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Page", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "ps_file", argType = TInterface "Poppler" "PSFile", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_page_render_to_ps" poppler_page_render_to_ps :: +    Ptr Page ->                             -- _obj : TInterface "Poppler" "Page"+    Ptr PSFile ->                           -- ps_file : TInterface "Poppler" "PSFile"+    IO ()+++pageRenderToPs ::+    (MonadIO m, PageK a, PSFileK b) =>+    a ->                                    -- _obj+    b ->                                    -- ps_file+    m ()+pageRenderToPs _obj ps_file = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let ps_file' = unsafeManagedPtrCastPtr ps_file+    poppler_page_render_to_ps _obj' ps_file'+    touchManagedPtr _obj+    touchManagedPtr ps_file+    return ()++-- method Page::free_annot_mapping+-- method type : MemberFunction+-- Args : [Arg {argName = "list", argType = TGList (TInterface "Poppler" "AnnotMapping"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "list", argType = TGList (TInterface "Poppler" "AnnotMapping"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_page_free_annot_mapping" poppler_page_free_annot_mapping :: +    Ptr (GList (Ptr AnnotMapping)) ->       -- list : TGList (TInterface "Poppler" "AnnotMapping")+    IO ()+++pageFreeAnnotMapping ::+    (MonadIO m) =>+    [AnnotMapping] ->                       -- list+    m ()+pageFreeAnnotMapping list = liftIO $ do+    let list' = map unsafeManagedPtrGetPtr list+    list'' <- packGList list'+    poppler_page_free_annot_mapping list''+    mapM_ touchManagedPtr list+    g_list_free list''+    return ()++-- method Page::free_form_field_mapping+-- method type : MemberFunction+-- Args : [Arg {argName = "list", argType = TGList (TInterface "Poppler" "FormFieldMapping"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "list", argType = TGList (TInterface "Poppler" "FormFieldMapping"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_page_free_form_field_mapping" poppler_page_free_form_field_mapping :: +    Ptr (GList (Ptr FormFieldMapping)) ->   -- list : TGList (TInterface "Poppler" "FormFieldMapping")+    IO ()+++pageFreeFormFieldMapping ::+    (MonadIO m) =>+    [FormFieldMapping] ->                   -- list+    m ()+pageFreeFormFieldMapping list = liftIO $ do+    let list' = map unsafeManagedPtrGetPtr list+    list'' <- packGList list'+    poppler_page_free_form_field_mapping list''+    mapM_ touchManagedPtr list+    g_list_free list''+    return ()++-- method Page::free_image_mapping+-- method type : MemberFunction+-- Args : [Arg {argName = "list", argType = TGList (TInterface "Poppler" "ImageMapping"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "list", argType = TGList (TInterface "Poppler" "ImageMapping"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_page_free_image_mapping" poppler_page_free_image_mapping :: +    Ptr (GList (Ptr ImageMapping)) ->       -- list : TGList (TInterface "Poppler" "ImageMapping")+    IO ()+++pageFreeImageMapping ::+    (MonadIO m) =>+    [ImageMapping] ->                       -- list+    m ()+pageFreeImageMapping list = liftIO $ do+    let list' = map unsafeManagedPtrGetPtr list+    list'' <- packGList list'+    poppler_page_free_image_mapping list''+    mapM_ touchManagedPtr list+    g_list_free list''+    return ()++-- method Page::free_link_mapping+-- method type : MemberFunction+-- Args : [Arg {argName = "list", argType = TGList (TInterface "Poppler" "LinkMapping"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "list", argType = TGList (TInterface "Poppler" "LinkMapping"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_page_free_link_mapping" poppler_page_free_link_mapping :: +    Ptr (GList (Ptr LinkMapping)) ->        -- list : TGList (TInterface "Poppler" "LinkMapping")+    IO ()+++pageFreeLinkMapping ::+    (MonadIO m) =>+    [LinkMapping] ->                        -- list+    m ()+pageFreeLinkMapping list = liftIO $ do+    let list' = map unsafeManagedPtrGetPtr list+    list'' <- packGList list'+    poppler_page_free_link_mapping list''+    mapM_ touchManagedPtr list+    g_list_free list''+    return ()++-- method Page::free_text_attributes+-- method type : MemberFunction+-- Args : [Arg {argName = "list", argType = TGList (TInterface "Poppler" "TextAttributes"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "list", argType = TGList (TInterface "Poppler" "TextAttributes"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_page_free_text_attributes" poppler_page_free_text_attributes :: +    Ptr (GList (Ptr TextAttributes)) ->     -- list : TGList (TInterface "Poppler" "TextAttributes")+    IO ()+++pageFreeTextAttributes ::+    (MonadIO m) =>+    [TextAttributes] ->                     -- list+    m ()+pageFreeTextAttributes list = liftIO $ do+    let list' = map unsafeManagedPtrGetPtr list+    list'' <- packGList list'+    poppler_page_free_text_attributes list''+    mapM_ touchManagedPtr list+    g_list_free list''+    return ()++-- method Page::selection_region_free+-- method type : MemberFunction+-- Args : [Arg {argName = "region", argType = TGList (TInterface "Poppler" "Rectangle"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "region", argType = TGList (TInterface "Poppler" "Rectangle"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_page_selection_region_free" poppler_page_selection_region_free :: +    Ptr (GList (Ptr Rectangle)) ->          -- region : TGList (TInterface "Poppler" "Rectangle")+    IO ()++{-# DEPRECATED pageSelectionRegionFree ["(Since version 0.16)"]#-}+pageSelectionRegionFree ::+    (MonadIO m) =>+    [Rectangle] ->                          -- region+    m ()+pageSelectionRegionFree region = liftIO $ do+    let region' = map unsafeManagedPtrGetPtr region+    region'' <- packGList region'+    poppler_page_selection_region_free region''+    mapM_ touchManagedPtr region+    g_list_free region''+    return ()++
+ GI/Poppler/Objects/Page.hs-boot view
@@ -0,0 +1,14 @@+module GI.Poppler.Objects.Page where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype Page = Page (ForeignPtr Page)+instance GObject Page where+class GObject o => PageK o+instance (GObject o, IsDescendantOf Page o) => PageK o+data PageLabelPropertyInfo
+ GI/Poppler/Objects/StructureElement.hs view
@@ -0,0 +1,1741 @@++{- |+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.StructureElement+    ( ++-- * Exported types+    StructureElement(..)                    ,+    StructureElementK                       ,+    toStructureElement                      ,+    noStructureElement                      ,+++ -- * Methods+-- ** structureElementGetAbbreviation+    structureElementGetAbbreviation         ,+++-- ** structureElementGetActualText+    structureElementGetActualText           ,+++-- ** structureElementGetAltText+    structureElementGetAltText              ,+++-- ** structureElementGetBackgroundColor+    structureElementGetBackgroundColor      ,+++-- ** structureElementGetBaselineShift+    structureElementGetBaselineShift        ,+++-- ** structureElementGetBlockAlign+    structureElementGetBlockAlign           ,+++-- ** structureElementGetBorderColor+    structureElementGetBorderColor          ,+++-- ** structureElementGetBorderStyle+    structureElementGetBorderStyle          ,+++-- ** structureElementGetBorderThickness+    structureElementGetBorderThickness      ,+++-- ** structureElementGetBoundingBox+    structureElementGetBoundingBox          ,+++-- ** structureElementGetColor+    structureElementGetColor                ,+++-- ** structureElementGetColumnCount+    structureElementGetColumnCount          ,+++-- ** structureElementGetColumnGaps+    structureElementGetColumnGaps           ,+++-- ** structureElementGetColumnWidths+    structureElementGetColumnWidths         ,+++-- ** structureElementGetEndIndent+    structureElementGetEndIndent            ,+++-- ** structureElementGetFormDescription+    structureElementGetFormDescription      ,+++-- ** structureElementGetFormRole+    structureElementGetFormRole             ,+++-- ** structureElementGetFormState+    structureElementGetFormState            ,+++-- ** structureElementGetGlyphOrientation+    structureElementGetGlyphOrientation     ,+++-- ** structureElementGetHeight+    structureElementGetHeight               ,+++-- ** structureElementGetId+    structureElementGetId                   ,+++-- ** structureElementGetInlineAlign+    structureElementGetInlineAlign          ,+++-- ** structureElementGetKind+    structureElementGetKind                 ,+++-- ** structureElementGetLanguage+    structureElementGetLanguage             ,+++-- ** structureElementGetLineHeight+    structureElementGetLineHeight           ,+++-- ** structureElementGetListNumbering+    structureElementGetListNumbering        ,+++-- ** structureElementGetPadding+    structureElementGetPadding              ,+++-- ** structureElementGetPage+    structureElementGetPage                 ,+++-- ** structureElementGetPlacement+    structureElementGetPlacement            ,+++-- ** structureElementGetRubyAlign+    structureElementGetRubyAlign            ,+++-- ** structureElementGetRubyPosition+    structureElementGetRubyPosition         ,+++-- ** structureElementGetSpaceAfter+    structureElementGetSpaceAfter           ,+++-- ** structureElementGetSpaceBefore+    structureElementGetSpaceBefore          ,+++-- ** structureElementGetStartIndent+    structureElementGetStartIndent          ,+++-- ** structureElementGetTableBorderStyle+    structureElementGetTableBorderStyle     ,+++-- ** structureElementGetTableColumnSpan+    structureElementGetTableColumnSpan      ,+++-- ** structureElementGetTableHeaders+    structureElementGetTableHeaders         ,+++-- ** structureElementGetTablePadding+    structureElementGetTablePadding         ,+++-- ** structureElementGetTableRowSpan+    structureElementGetTableRowSpan         ,+++-- ** structureElementGetTableScope+    structureElementGetTableScope           ,+++-- ** structureElementGetTableSummary+    structureElementGetTableSummary         ,+++-- ** structureElementGetText+    structureElementGetText                 ,+++-- ** structureElementGetTextAlign+    structureElementGetTextAlign            ,+++-- ** structureElementGetTextDecorationColor+    structureElementGetTextDecorationColor  ,+++-- ** structureElementGetTextDecorationThickness+    structureElementGetTextDecorationThickness,+++-- ** structureElementGetTextDecorationType+    structureElementGetTextDecorationType   ,+++-- ** structureElementGetTextIndent+    structureElementGetTextIndent           ,+++-- ** structureElementGetTextSpans+    structureElementGetTextSpans            ,+++-- ** structureElementGetTitle+    structureElementGetTitle                ,+++-- ** structureElementGetWidth+    structureElementGetWidth                ,+++-- ** structureElementGetWritingMode+    structureElementGetWritingMode          ,+++-- ** structureElementIsBlock+    structureElementIsBlock                 ,+++-- ** structureElementIsContent+    structureElementIsContent               ,+++-- ** structureElementIsGrouping+    structureElementIsGrouping              ,+++-- ** structureElementIsInline+    structureElementIsInline                ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Poppler.Types+import GI.Poppler.Callbacks+import qualified GI.GObject as GObject++newtype StructureElement = StructureElement (ForeignPtr StructureElement)+foreign import ccall "poppler_structure_element_get_type"+    c_poppler_structure_element_get_type :: IO GType++type instance ParentTypes StructureElement = StructureElementParentTypes+type StructureElementParentTypes = '[GObject.Object]++instance GObject StructureElement where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_poppler_structure_element_get_type+    ++class GObject o => StructureElementK o+instance (GObject o, IsDescendantOf StructureElement o) => StructureElementK o++toStructureElement :: StructureElementK o => o -> IO StructureElement+toStructureElement = unsafeCastTo StructureElement++noStructureElement :: Maybe StructureElement+noStructureElement = Nothing++type instance AttributeList StructureElement = StructureElementAttributeList+type StructureElementAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList StructureElement = StructureElementSignalList+type StructureElementSignalList = ('[ '("notify", GObject.ObjectNotifySignalInfo), '("notify::[property]", GObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method StructureElement::get_abbreviation+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "poppler_structure_element_get_abbreviation" poppler_structure_element_get_abbreviation :: +    Ptr StructureElement ->                 -- _obj : TInterface "Poppler" "StructureElement"+    IO CString+++structureElementGetAbbreviation ::+    (MonadIO m, StructureElementK a) =>+    a ->                                    -- _obj+    m T.Text+structureElementGetAbbreviation _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_structure_element_get_abbreviation _obj'+    checkUnexpectedReturnNULL "poppler_structure_element_get_abbreviation" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method StructureElement::get_actual_text+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "poppler_structure_element_get_actual_text" poppler_structure_element_get_actual_text :: +    Ptr StructureElement ->                 -- _obj : TInterface "Poppler" "StructureElement"+    IO CString+++structureElementGetActualText ::+    (MonadIO m, StructureElementK a) =>+    a ->                                    -- _obj+    m T.Text+structureElementGetActualText _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_structure_element_get_actual_text _obj'+    checkUnexpectedReturnNULL "poppler_structure_element_get_actual_text" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method StructureElement::get_alt_text+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "poppler_structure_element_get_alt_text" poppler_structure_element_get_alt_text :: +    Ptr StructureElement ->                 -- _obj : TInterface "Poppler" "StructureElement"+    IO CString+++structureElementGetAltText ::+    (MonadIO m, StructureElementK a) =>+    a ->                                    -- _obj+    m T.Text+structureElementGetAltText _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_structure_element_get_alt_text _obj'+    checkUnexpectedReturnNULL "poppler_structure_element_get_alt_text" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method StructureElement::get_background_color+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "color", argType = TInterface "Poppler" "Color", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "poppler_structure_element_get_background_color" poppler_structure_element_get_background_color :: +    Ptr StructureElement ->                 -- _obj : TInterface "Poppler" "StructureElement"+    Ptr Color ->                            -- color : TInterface "Poppler" "Color"+    IO CInt+++structureElementGetBackgroundColor ::+    (MonadIO m, StructureElementK a) =>+    a ->                                    -- _obj+    m (Bool,Color)+structureElementGetBackgroundColor _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    color <- callocBoxedBytes 6 :: IO (Ptr Color)+    result <- poppler_structure_element_get_background_color _obj' color+    let result' = (/= 0) result+    color' <- (wrapBoxed Color) color+    touchManagedPtr _obj+    return (result', color')++-- method StructureElement::get_baseline_shift+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TDouble+-- throws : False+-- Skip return : False++foreign import ccall "poppler_structure_element_get_baseline_shift" poppler_structure_element_get_baseline_shift :: +    Ptr StructureElement ->                 -- _obj : TInterface "Poppler" "StructureElement"+    IO CDouble+++structureElementGetBaselineShift ::+    (MonadIO m, StructureElementK a) =>+    a ->                                    -- _obj+    m Double+structureElementGetBaselineShift _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_structure_element_get_baseline_shift _obj'+    let result' = realToFrac result+    touchManagedPtr _obj+    return result'++-- method StructureElement::get_block_align+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "StructureBlockAlign"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_structure_element_get_block_align" poppler_structure_element_get_block_align :: +    Ptr StructureElement ->                 -- _obj : TInterface "Poppler" "StructureElement"+    IO CUInt+++structureElementGetBlockAlign ::+    (MonadIO m, StructureElementK a) =>+    a ->                                    -- _obj+    m StructureBlockAlign+structureElementGetBlockAlign _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_structure_element_get_block_align _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method StructureElement::get_border_color+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "colors", argType = TCArray False 4 (-1) (TInterface "Poppler" "Color"), direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "poppler_structure_element_get_border_color" poppler_structure_element_get_border_color :: +    Ptr StructureElement ->                 -- _obj : TInterface "Poppler" "StructureElement"+    Ptr (Ptr Color) ->                      -- colors : TCArray False 4 (-1) (TInterface "Poppler" "Color")+    IO CInt+++structureElementGetBorderColor ::+    (MonadIO m, StructureElementK a) =>+    a ->                                    -- _obj+    m (Bool,[Color])+structureElementGetBorderColor _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    colors <- allocMem :: IO (Ptr (Ptr Color))+    result <- poppler_structure_element_get_border_color _obj' colors+    let result' = (/= 0) result+    colors' <- peek colors+    colors'' <- (unpackBoxedArrayWithLength 6 4) colors'+    colors''' <- mapM (newBoxed Color) colors''+    touchManagedPtr _obj+    freeMem colors+    return (result', colors''')++-- method StructureElement::get_border_style+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "border_styles", argType = TCArray False 4 (-1) (TInterface "Poppler" "StructureBorderStyle"), direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_structure_element_get_border_style" poppler_structure_element_get_border_style :: +    Ptr StructureElement ->                 -- _obj : TInterface "Poppler" "StructureElement"+    Ptr (Ptr CUInt) ->                      -- border_styles : TCArray False 4 (-1) (TInterface "Poppler" "StructureBorderStyle")+    IO ()+++structureElementGetBorderStyle ::+    (MonadIO m, StructureElementK a) =>+    a ->                                    -- _obj+    m ([StructureBorderStyle])+structureElementGetBorderStyle _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    border_styles <- allocMem :: IO (Ptr (Ptr CUInt))+    poppler_structure_element_get_border_style _obj' border_styles+    border_styles' <- peek border_styles+    border_styles'' <- (unpackStorableArrayWithLength 4) border_styles'+    let border_styles''' = map (toEnum . fromIntegral) border_styles''+    freeMem border_styles'+    touchManagedPtr _obj+    freeMem border_styles+    return border_styles'''++-- method StructureElement::get_border_thickness+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "border_thicknesses", argType = TCArray False 4 (-1) (TBasicType TDouble), direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "poppler_structure_element_get_border_thickness" poppler_structure_element_get_border_thickness :: +    Ptr StructureElement ->                 -- _obj : TInterface "Poppler" "StructureElement"+    Ptr (Ptr CDouble) ->                    -- border_thicknesses : TCArray False 4 (-1) (TBasicType TDouble)+    IO CInt+++structureElementGetBorderThickness ::+    (MonadIO m, StructureElementK a) =>+    a ->                                    -- _obj+    m (Bool,[Double])+structureElementGetBorderThickness _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    border_thicknesses <- allocMem :: IO (Ptr (Ptr CDouble))+    result <- poppler_structure_element_get_border_thickness _obj' border_thicknesses+    let result' = (/= 0) result+    border_thicknesses' <- peek border_thicknesses+    border_thicknesses'' <- (unpackMapStorableArrayWithLength realToFrac 4) border_thicknesses'+    freeMem border_thicknesses'+    touchManagedPtr _obj+    freeMem border_thicknesses+    return (result', border_thicknesses'')++-- method StructureElement::get_bounding_box+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "bounding_box", argType = TInterface "Poppler" "Rectangle", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "poppler_structure_element_get_bounding_box" poppler_structure_element_get_bounding_box :: +    Ptr StructureElement ->                 -- _obj : TInterface "Poppler" "StructureElement"+    Ptr Rectangle ->                        -- bounding_box : TInterface "Poppler" "Rectangle"+    IO CInt+++structureElementGetBoundingBox ::+    (MonadIO m, StructureElementK a) =>+    a ->                                    -- _obj+    m (Bool,Rectangle)+structureElementGetBoundingBox _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    bounding_box <- callocBoxedBytes 32 :: IO (Ptr Rectangle)+    result <- poppler_structure_element_get_bounding_box _obj' bounding_box+    let result' = (/= 0) result+    bounding_box' <- (wrapBoxed Rectangle) bounding_box+    touchManagedPtr _obj+    return (result', bounding_box')++-- method StructureElement::get_color+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "color", argType = TInterface "Poppler" "Color", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "poppler_structure_element_get_color" poppler_structure_element_get_color :: +    Ptr StructureElement ->                 -- _obj : TInterface "Poppler" "StructureElement"+    Ptr Color ->                            -- color : TInterface "Poppler" "Color"+    IO CInt+++structureElementGetColor ::+    (MonadIO m, StructureElementK a) =>+    a ->                                    -- _obj+    m (Bool,Color)+structureElementGetColor _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    color <- callocBoxedBytes 6 :: IO (Ptr Color)+    result <- poppler_structure_element_get_color _obj' color+    let result' = (/= 0) result+    color' <- (wrapBoxed Color) color+    touchManagedPtr _obj+    return (result', color')++-- method StructureElement::get_column_count+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "poppler_structure_element_get_column_count" poppler_structure_element_get_column_count :: +    Ptr StructureElement ->                 -- _obj : TInterface "Poppler" "StructureElement"+    IO Word32+++structureElementGetColumnCount ::+    (MonadIO m, StructureElementK a) =>+    a ->                                    -- _obj+    m Word32+structureElementGetColumnCount _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_structure_element_get_column_count _obj'+    touchManagedPtr _obj+    return result++-- method StructureElement::get_column_gaps+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_values", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : [Arg {argName = "n_values", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TCArray False (-1) 1 (TBasicType TDouble)+-- throws : False+-- Skip return : False++foreign import ccall "poppler_structure_element_get_column_gaps" poppler_structure_element_get_column_gaps :: +    Ptr StructureElement ->                 -- _obj : TInterface "Poppler" "StructureElement"+    Ptr Word32 ->                           -- n_values : TBasicType TUInt32+    IO (Ptr CDouble)+++structureElementGetColumnGaps ::+    (MonadIO m, StructureElementK a) =>+    a ->                                    -- _obj+    m [Double]+structureElementGetColumnGaps _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    n_values <- allocMem :: IO (Ptr Word32)+    result <- poppler_structure_element_get_column_gaps _obj' n_values+    n_values' <- peek n_values+    checkUnexpectedReturnNULL "poppler_structure_element_get_column_gaps" result+    result' <- (unpackMapStorableArrayWithLength realToFrac n_values') result+    freeMem result+    touchManagedPtr _obj+    freeMem n_values+    return result'++-- method StructureElement::get_column_widths+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_values", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : [Arg {argName = "n_values", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TCArray False (-1) 1 (TBasicType TDouble)+-- throws : False+-- Skip return : False++foreign import ccall "poppler_structure_element_get_column_widths" poppler_structure_element_get_column_widths :: +    Ptr StructureElement ->                 -- _obj : TInterface "Poppler" "StructureElement"+    Ptr Word32 ->                           -- n_values : TBasicType TUInt32+    IO (Ptr CDouble)+++structureElementGetColumnWidths ::+    (MonadIO m, StructureElementK a) =>+    a ->                                    -- _obj+    m [Double]+structureElementGetColumnWidths _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    n_values <- allocMem :: IO (Ptr Word32)+    result <- poppler_structure_element_get_column_widths _obj' n_values+    n_values' <- peek n_values+    checkUnexpectedReturnNULL "poppler_structure_element_get_column_widths" result+    result' <- (unpackMapStorableArrayWithLength realToFrac n_values') result+    freeMem result+    touchManagedPtr _obj+    freeMem n_values+    return result'++-- method StructureElement::get_end_indent+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TDouble+-- throws : False+-- Skip return : False++foreign import ccall "poppler_structure_element_get_end_indent" poppler_structure_element_get_end_indent :: +    Ptr StructureElement ->                 -- _obj : TInterface "Poppler" "StructureElement"+    IO CDouble+++structureElementGetEndIndent ::+    (MonadIO m, StructureElementK a) =>+    a ->                                    -- _obj+    m Double+structureElementGetEndIndent _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_structure_element_get_end_indent _obj'+    let result' = realToFrac result+    touchManagedPtr _obj+    return result'++-- method StructureElement::get_form_description+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "poppler_structure_element_get_form_description" poppler_structure_element_get_form_description :: +    Ptr StructureElement ->                 -- _obj : TInterface "Poppler" "StructureElement"+    IO CString+++structureElementGetFormDescription ::+    (MonadIO m, StructureElementK a) =>+    a ->                                    -- _obj+    m T.Text+structureElementGetFormDescription _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_structure_element_get_form_description _obj'+    checkUnexpectedReturnNULL "poppler_structure_element_get_form_description" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method StructureElement::get_form_role+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "StructureFormRole"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_structure_element_get_form_role" poppler_structure_element_get_form_role :: +    Ptr StructureElement ->                 -- _obj : TInterface "Poppler" "StructureElement"+    IO CUInt+++structureElementGetFormRole ::+    (MonadIO m, StructureElementK a) =>+    a ->                                    -- _obj+    m StructureFormRole+structureElementGetFormRole _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_structure_element_get_form_role _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method StructureElement::get_form_state+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "StructureFormState"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_structure_element_get_form_state" poppler_structure_element_get_form_state :: +    Ptr StructureElement ->                 -- _obj : TInterface "Poppler" "StructureElement"+    IO CUInt+++structureElementGetFormState ::+    (MonadIO m, StructureElementK a) =>+    a ->                                    -- _obj+    m StructureFormState+structureElementGetFormState _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_structure_element_get_form_state _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method StructureElement::get_glyph_orientation+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "StructureGlyphOrientation"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_structure_element_get_glyph_orientation" poppler_structure_element_get_glyph_orientation :: +    Ptr StructureElement ->                 -- _obj : TInterface "Poppler" "StructureElement"+    IO CUInt+++structureElementGetGlyphOrientation ::+    (MonadIO m, StructureElementK a) =>+    a ->                                    -- _obj+    m StructureGlyphOrientation+structureElementGetGlyphOrientation _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_structure_element_get_glyph_orientation _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method StructureElement::get_height+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TDouble+-- throws : False+-- Skip return : False++foreign import ccall "poppler_structure_element_get_height" poppler_structure_element_get_height :: +    Ptr StructureElement ->                 -- _obj : TInterface "Poppler" "StructureElement"+    IO CDouble+++structureElementGetHeight ::+    (MonadIO m, StructureElementK a) =>+    a ->                                    -- _obj+    m Double+structureElementGetHeight _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_structure_element_get_height _obj'+    let result' = realToFrac result+    touchManagedPtr _obj+    return result'++-- method StructureElement::get_id+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "poppler_structure_element_get_id" poppler_structure_element_get_id :: +    Ptr StructureElement ->                 -- _obj : TInterface "Poppler" "StructureElement"+    IO CString+++structureElementGetId ::+    (MonadIO m, StructureElementK a) =>+    a ->                                    -- _obj+    m T.Text+structureElementGetId _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_structure_element_get_id _obj'+    checkUnexpectedReturnNULL "poppler_structure_element_get_id" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method StructureElement::get_inline_align+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "StructureInlineAlign"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_structure_element_get_inline_align" poppler_structure_element_get_inline_align :: +    Ptr StructureElement ->                 -- _obj : TInterface "Poppler" "StructureElement"+    IO CUInt+++structureElementGetInlineAlign ::+    (MonadIO m, StructureElementK a) =>+    a ->                                    -- _obj+    m StructureInlineAlign+structureElementGetInlineAlign _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_structure_element_get_inline_align _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method StructureElement::get_kind+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "StructureElementKind"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_structure_element_get_kind" poppler_structure_element_get_kind :: +    Ptr StructureElement ->                 -- _obj : TInterface "Poppler" "StructureElement"+    IO CUInt+++structureElementGetKind ::+    (MonadIO m, StructureElementK a) =>+    a ->                                    -- _obj+    m StructureElementKind+structureElementGetKind _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_structure_element_get_kind _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method StructureElement::get_language+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "poppler_structure_element_get_language" poppler_structure_element_get_language :: +    Ptr StructureElement ->                 -- _obj : TInterface "Poppler" "StructureElement"+    IO CString+++structureElementGetLanguage ::+    (MonadIO m, StructureElementK a) =>+    a ->                                    -- _obj+    m T.Text+structureElementGetLanguage _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_structure_element_get_language _obj'+    checkUnexpectedReturnNULL "poppler_structure_element_get_language" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method StructureElement::get_line_height+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TDouble+-- throws : False+-- Skip return : False++foreign import ccall "poppler_structure_element_get_line_height" poppler_structure_element_get_line_height :: +    Ptr StructureElement ->                 -- _obj : TInterface "Poppler" "StructureElement"+    IO CDouble+++structureElementGetLineHeight ::+    (MonadIO m, StructureElementK a) =>+    a ->                                    -- _obj+    m Double+structureElementGetLineHeight _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_structure_element_get_line_height _obj'+    let result' = realToFrac result+    touchManagedPtr _obj+    return result'++-- method StructureElement::get_list_numbering+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "StructureListNumbering"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_structure_element_get_list_numbering" poppler_structure_element_get_list_numbering :: +    Ptr StructureElement ->                 -- _obj : TInterface "Poppler" "StructureElement"+    IO CUInt+++structureElementGetListNumbering ::+    (MonadIO m, StructureElementK a) =>+    a ->                                    -- _obj+    m StructureListNumbering+structureElementGetListNumbering _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_structure_element_get_list_numbering _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method StructureElement::get_padding+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "paddings", argType = TCArray False 4 (-1) (TBasicType TDouble), direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_structure_element_get_padding" poppler_structure_element_get_padding :: +    Ptr StructureElement ->                 -- _obj : TInterface "Poppler" "StructureElement"+    Ptr (Ptr CDouble) ->                    -- paddings : TCArray False 4 (-1) (TBasicType TDouble)+    IO ()+++structureElementGetPadding ::+    (MonadIO m, StructureElementK a) =>+    a ->                                    -- _obj+    m ([Double])+structureElementGetPadding _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    paddings <- allocMem :: IO (Ptr (Ptr CDouble))+    poppler_structure_element_get_padding _obj' paddings+    paddings' <- peek paddings+    paddings'' <- (unpackMapStorableArrayWithLength realToFrac 4) paddings'+    freeMem paddings'+    touchManagedPtr _obj+    freeMem paddings+    return paddings''++-- method StructureElement::get_page+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "poppler_structure_element_get_page" poppler_structure_element_get_page :: +    Ptr StructureElement ->                 -- _obj : TInterface "Poppler" "StructureElement"+    IO Int32+++structureElementGetPage ::+    (MonadIO m, StructureElementK a) =>+    a ->                                    -- _obj+    m Int32+structureElementGetPage _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_structure_element_get_page _obj'+    touchManagedPtr _obj+    return result++-- method StructureElement::get_placement+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "StructurePlacement"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_structure_element_get_placement" poppler_structure_element_get_placement :: +    Ptr StructureElement ->                 -- _obj : TInterface "Poppler" "StructureElement"+    IO CUInt+++structureElementGetPlacement ::+    (MonadIO m, StructureElementK a) =>+    a ->                                    -- _obj+    m StructurePlacement+structureElementGetPlacement _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_structure_element_get_placement _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method StructureElement::get_ruby_align+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "StructureRubyAlign"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_structure_element_get_ruby_align" poppler_structure_element_get_ruby_align :: +    Ptr StructureElement ->                 -- _obj : TInterface "Poppler" "StructureElement"+    IO CUInt+++structureElementGetRubyAlign ::+    (MonadIO m, StructureElementK a) =>+    a ->                                    -- _obj+    m StructureRubyAlign+structureElementGetRubyAlign _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_structure_element_get_ruby_align _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method StructureElement::get_ruby_position+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "StructureRubyPosition"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_structure_element_get_ruby_position" poppler_structure_element_get_ruby_position :: +    Ptr StructureElement ->                 -- _obj : TInterface "Poppler" "StructureElement"+    IO CUInt+++structureElementGetRubyPosition ::+    (MonadIO m, StructureElementK a) =>+    a ->                                    -- _obj+    m StructureRubyPosition+structureElementGetRubyPosition _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_structure_element_get_ruby_position _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method StructureElement::get_space_after+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TDouble+-- throws : False+-- Skip return : False++foreign import ccall "poppler_structure_element_get_space_after" poppler_structure_element_get_space_after :: +    Ptr StructureElement ->                 -- _obj : TInterface "Poppler" "StructureElement"+    IO CDouble+++structureElementGetSpaceAfter ::+    (MonadIO m, StructureElementK a) =>+    a ->                                    -- _obj+    m Double+structureElementGetSpaceAfter _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_structure_element_get_space_after _obj'+    let result' = realToFrac result+    touchManagedPtr _obj+    return result'++-- method StructureElement::get_space_before+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TDouble+-- throws : False+-- Skip return : False++foreign import ccall "poppler_structure_element_get_space_before" poppler_structure_element_get_space_before :: +    Ptr StructureElement ->                 -- _obj : TInterface "Poppler" "StructureElement"+    IO CDouble+++structureElementGetSpaceBefore ::+    (MonadIO m, StructureElementK a) =>+    a ->                                    -- _obj+    m Double+structureElementGetSpaceBefore _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_structure_element_get_space_before _obj'+    let result' = realToFrac result+    touchManagedPtr _obj+    return result'++-- method StructureElement::get_start_indent+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TDouble+-- throws : False+-- Skip return : False++foreign import ccall "poppler_structure_element_get_start_indent" poppler_structure_element_get_start_indent :: +    Ptr StructureElement ->                 -- _obj : TInterface "Poppler" "StructureElement"+    IO CDouble+++structureElementGetStartIndent ::+    (MonadIO m, StructureElementK a) =>+    a ->                                    -- _obj+    m Double+structureElementGetStartIndent _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_structure_element_get_start_indent _obj'+    let result' = realToFrac result+    touchManagedPtr _obj+    return result'++-- method StructureElement::get_table_border_style+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "border_styles", argType = TCArray False 4 (-1) (TInterface "Poppler" "StructureBorderStyle"), direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_structure_element_get_table_border_style" poppler_structure_element_get_table_border_style :: +    Ptr StructureElement ->                 -- _obj : TInterface "Poppler" "StructureElement"+    Ptr (Ptr CUInt) ->                      -- border_styles : TCArray False 4 (-1) (TInterface "Poppler" "StructureBorderStyle")+    IO ()+++structureElementGetTableBorderStyle ::+    (MonadIO m, StructureElementK a) =>+    a ->                                    -- _obj+    m ([StructureBorderStyle])+structureElementGetTableBorderStyle _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    border_styles <- allocMem :: IO (Ptr (Ptr CUInt))+    poppler_structure_element_get_table_border_style _obj' border_styles+    border_styles' <- peek border_styles+    border_styles'' <- (unpackStorableArrayWithLength 4) border_styles'+    let border_styles''' = map (toEnum . fromIntegral) border_styles''+    freeMem border_styles'+    touchManagedPtr _obj+    freeMem border_styles+    return border_styles'''++-- method StructureElement::get_table_column_span+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "poppler_structure_element_get_table_column_span" poppler_structure_element_get_table_column_span :: +    Ptr StructureElement ->                 -- _obj : TInterface "Poppler" "StructureElement"+    IO Word32+++structureElementGetTableColumnSpan ::+    (MonadIO m, StructureElementK a) =>+    a ->                                    -- _obj+    m Word32+structureElementGetTableColumnSpan _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_structure_element_get_table_column_span _obj'+    touchManagedPtr _obj+    return result++-- method StructureElement::get_table_headers+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TCArray True (-1) (-1) (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "poppler_structure_element_get_table_headers" poppler_structure_element_get_table_headers :: +    Ptr StructureElement ->                 -- _obj : TInterface "Poppler" "StructureElement"+    IO (Ptr CString)+++structureElementGetTableHeaders ::+    (MonadIO m, StructureElementK a) =>+    a ->                                    -- _obj+    m [T.Text]+structureElementGetTableHeaders _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_structure_element_get_table_headers _obj'+    checkUnexpectedReturnNULL "poppler_structure_element_get_table_headers" result+    result' <- unpackZeroTerminatedUTF8CArray result+    mapZeroTerminatedCArray freeMem result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method StructureElement::get_table_padding+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "paddings", argType = TCArray False 4 (-1) (TBasicType TDouble), direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_structure_element_get_table_padding" poppler_structure_element_get_table_padding :: +    Ptr StructureElement ->                 -- _obj : TInterface "Poppler" "StructureElement"+    Ptr (Ptr CDouble) ->                    -- paddings : TCArray False 4 (-1) (TBasicType TDouble)+    IO ()+++structureElementGetTablePadding ::+    (MonadIO m, StructureElementK a) =>+    a ->                                    -- _obj+    m ([Double])+structureElementGetTablePadding _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    paddings <- allocMem :: IO (Ptr (Ptr CDouble))+    poppler_structure_element_get_table_padding _obj' paddings+    paddings' <- peek paddings+    paddings'' <- (unpackMapStorableArrayWithLength realToFrac 4) paddings'+    freeMem paddings'+    touchManagedPtr _obj+    freeMem paddings+    return paddings''++-- method StructureElement::get_table_row_span+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "poppler_structure_element_get_table_row_span" poppler_structure_element_get_table_row_span :: +    Ptr StructureElement ->                 -- _obj : TInterface "Poppler" "StructureElement"+    IO Word32+++structureElementGetTableRowSpan ::+    (MonadIO m, StructureElementK a) =>+    a ->                                    -- _obj+    m Word32+structureElementGetTableRowSpan _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_structure_element_get_table_row_span _obj'+    touchManagedPtr _obj+    return result++-- method StructureElement::get_table_scope+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "StructureTableScope"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_structure_element_get_table_scope" poppler_structure_element_get_table_scope :: +    Ptr StructureElement ->                 -- _obj : TInterface "Poppler" "StructureElement"+    IO CUInt+++structureElementGetTableScope ::+    (MonadIO m, StructureElementK a) =>+    a ->                                    -- _obj+    m StructureTableScope+structureElementGetTableScope _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_structure_element_get_table_scope _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method StructureElement::get_table_summary+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "poppler_structure_element_get_table_summary" poppler_structure_element_get_table_summary :: +    Ptr StructureElement ->                 -- _obj : TInterface "Poppler" "StructureElement"+    IO CString+++structureElementGetTableSummary ::+    (MonadIO m, StructureElementK a) =>+    a ->                                    -- _obj+    m T.Text+structureElementGetTableSummary _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_structure_element_get_table_summary _obj'+    checkUnexpectedReturnNULL "poppler_structure_element_get_table_summary" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method StructureElement::get_text+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Poppler" "StructureGetTextFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "flags", argType = TInterface "Poppler" "StructureGetTextFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "poppler_structure_element_get_text" poppler_structure_element_get_text :: +    Ptr StructureElement ->                 -- _obj : TInterface "Poppler" "StructureElement"+    CUInt ->                                -- flags : TInterface "Poppler" "StructureGetTextFlags"+    IO CString+++structureElementGetText ::+    (MonadIO m, StructureElementK a) =>+    a ->                                    -- _obj+    [StructureGetTextFlags] ->              -- flags+    m T.Text+structureElementGetText _obj flags = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let flags' = gflagsToWord flags+    result <- poppler_structure_element_get_text _obj' flags'+    checkUnexpectedReturnNULL "poppler_structure_element_get_text" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method StructureElement::get_text_align+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "StructureTextAlign"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_structure_element_get_text_align" poppler_structure_element_get_text_align :: +    Ptr StructureElement ->                 -- _obj : TInterface "Poppler" "StructureElement"+    IO CUInt+++structureElementGetTextAlign ::+    (MonadIO m, StructureElementK a) =>+    a ->                                    -- _obj+    m StructureTextAlign+structureElementGetTextAlign _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_structure_element_get_text_align _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method StructureElement::get_text_decoration_color+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "color", argType = TInterface "Poppler" "Color", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "poppler_structure_element_get_text_decoration_color" poppler_structure_element_get_text_decoration_color :: +    Ptr StructureElement ->                 -- _obj : TInterface "Poppler" "StructureElement"+    Ptr Color ->                            -- color : TInterface "Poppler" "Color"+    IO CInt+++structureElementGetTextDecorationColor ::+    (MonadIO m, StructureElementK a) =>+    a ->                                    -- _obj+    m (Bool,Color)+structureElementGetTextDecorationColor _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    color <- callocBoxedBytes 6 :: IO (Ptr Color)+    result <- poppler_structure_element_get_text_decoration_color _obj' color+    let result' = (/= 0) result+    color' <- (wrapBoxed Color) color+    touchManagedPtr _obj+    return (result', color')++-- method StructureElement::get_text_decoration_thickness+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TDouble+-- throws : False+-- Skip return : False++foreign import ccall "poppler_structure_element_get_text_decoration_thickness" poppler_structure_element_get_text_decoration_thickness :: +    Ptr StructureElement ->                 -- _obj : TInterface "Poppler" "StructureElement"+    IO CDouble+++structureElementGetTextDecorationThickness ::+    (MonadIO m, StructureElementK a) =>+    a ->                                    -- _obj+    m Double+structureElementGetTextDecorationThickness _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_structure_element_get_text_decoration_thickness _obj'+    let result' = realToFrac result+    touchManagedPtr _obj+    return result'++-- method StructureElement::get_text_decoration_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "StructureTextDecoration"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_structure_element_get_text_decoration_type" poppler_structure_element_get_text_decoration_type :: +    Ptr StructureElement ->                 -- _obj : TInterface "Poppler" "StructureElement"+    IO CUInt+++structureElementGetTextDecorationType ::+    (MonadIO m, StructureElementK a) =>+    a ->                                    -- _obj+    m StructureTextDecoration+structureElementGetTextDecorationType _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_structure_element_get_text_decoration_type _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method StructureElement::get_text_indent+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TDouble+-- throws : False+-- Skip return : False++foreign import ccall "poppler_structure_element_get_text_indent" poppler_structure_element_get_text_indent :: +    Ptr StructureElement ->                 -- _obj : TInterface "Poppler" "StructureElement"+    IO CDouble+++structureElementGetTextIndent ::+    (MonadIO m, StructureElementK a) =>+    a ->                                    -- _obj+    m Double+structureElementGetTextIndent _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_structure_element_get_text_indent _obj'+    let result' = realToFrac result+    touchManagedPtr _obj+    return result'++-- method StructureElement::get_text_spans+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "n_text_spans", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- Lengths : [Arg {argName = "n_text_spans", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferEverything}]+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TCArray False (-1) 1 (TInterface "Poppler" "TextSpan")+-- throws : False+-- Skip return : False++foreign import ccall "poppler_structure_element_get_text_spans" poppler_structure_element_get_text_spans :: +    Ptr StructureElement ->                 -- _obj : TInterface "Poppler" "StructureElement"+    Ptr Word32 ->                           -- n_text_spans : TBasicType TUInt32+    IO (Ptr (Ptr TextSpan))+++structureElementGetTextSpans ::+    (MonadIO m, StructureElementK a) =>+    a ->                                    -- _obj+    m [TextSpan]+structureElementGetTextSpans _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    n_text_spans <- allocMem :: IO (Ptr Word32)+    result <- poppler_structure_element_get_text_spans _obj' n_text_spans+    n_text_spans' <- peek n_text_spans+    checkUnexpectedReturnNULL "poppler_structure_element_get_text_spans" result+    result' <- (unpackPtrArrayWithLength n_text_spans') result+    result'' <- mapM (wrapBoxed TextSpan) result'+    freeMem result+    touchManagedPtr _obj+    freeMem n_text_spans+    return result''++-- method StructureElement::get_title+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "poppler_structure_element_get_title" poppler_structure_element_get_title :: +    Ptr StructureElement ->                 -- _obj : TInterface "Poppler" "StructureElement"+    IO CString+++structureElementGetTitle ::+    (MonadIO m, StructureElementK a) =>+    a ->                                    -- _obj+    m T.Text+structureElementGetTitle _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_structure_element_get_title _obj'+    checkUnexpectedReturnNULL "poppler_structure_element_get_title" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method StructureElement::get_width+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TDouble+-- throws : False+-- Skip return : False++foreign import ccall "poppler_structure_element_get_width" poppler_structure_element_get_width :: +    Ptr StructureElement ->                 -- _obj : TInterface "Poppler" "StructureElement"+    IO CDouble+++structureElementGetWidth ::+    (MonadIO m, StructureElementK a) =>+    a ->                                    -- _obj+    m Double+structureElementGetWidth _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_structure_element_get_width _obj'+    let result' = realToFrac result+    touchManagedPtr _obj+    return result'++-- method StructureElement::get_writing_mode+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "StructureWritingMode"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_structure_element_get_writing_mode" poppler_structure_element_get_writing_mode :: +    Ptr StructureElement ->                 -- _obj : TInterface "Poppler" "StructureElement"+    IO CUInt+++structureElementGetWritingMode ::+    (MonadIO m, StructureElementK a) =>+    a ->                                    -- _obj+    m StructureWritingMode+structureElementGetWritingMode _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_structure_element_get_writing_mode _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method StructureElement::is_block+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "poppler_structure_element_is_block" poppler_structure_element_is_block :: +    Ptr StructureElement ->                 -- _obj : TInterface "Poppler" "StructureElement"+    IO CInt+++structureElementIsBlock ::+    (MonadIO m, StructureElementK a) =>+    a ->                                    -- _obj+    m Bool+structureElementIsBlock _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_structure_element_is_block _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method StructureElement::is_content+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "poppler_structure_element_is_content" poppler_structure_element_is_content :: +    Ptr StructureElement ->                 -- _obj : TInterface "Poppler" "StructureElement"+    IO CInt+++structureElementIsContent ::+    (MonadIO m, StructureElementK a) =>+    a ->                                    -- _obj+    m Bool+structureElementIsContent _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_structure_element_is_content _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method StructureElement::is_grouping+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "poppler_structure_element_is_grouping" poppler_structure_element_is_grouping :: +    Ptr StructureElement ->                 -- _obj : TInterface "Poppler" "StructureElement"+    IO CInt+++structureElementIsGrouping ::+    (MonadIO m, StructureElementK a) =>+    a ->                                    -- _obj+    m Bool+structureElementIsGrouping _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_structure_element_is_grouping _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method StructureElement::is_inline+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElement", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "poppler_structure_element_is_inline" poppler_structure_element_is_inline :: +    Ptr StructureElement ->                 -- _obj : TInterface "Poppler" "StructureElement"+    IO CInt+++structureElementIsInline ::+    (MonadIO m, StructureElementK a) =>+    a ->                                    -- _obj+    m Bool+structureElementIsInline _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- poppler_structure_element_is_inline _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++
+ GI/Poppler/Objects/StructureElement.hs-boot view
@@ -0,0 +1,13 @@+module GI.Poppler.Objects.StructureElement where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype StructureElement = StructureElement (ForeignPtr StructureElement)+instance GObject StructureElement where+class GObject o => StructureElementK o+instance (GObject o, IsDescendantOf StructureElement o) => StructureElementK o
+ GI/Poppler/Structs.hs view
@@ -0,0 +1,80 @@++{- |+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+    (     module GI.Poppler.Structs.ActionAny     ,+    module GI.Poppler.Structs.ActionGotoDest,+    module GI.Poppler.Structs.ActionGotoRemote,+    module GI.Poppler.Structs.ActionJavascript,+    module GI.Poppler.Structs.ActionLaunch  ,+    module GI.Poppler.Structs.ActionLayer   ,+    module GI.Poppler.Structs.ActionMovie   ,+    module GI.Poppler.Structs.ActionNamed   ,+    module GI.Poppler.Structs.ActionOCGState,+    module GI.Poppler.Structs.ActionRendition,+    module GI.Poppler.Structs.ActionUri     ,+    module GI.Poppler.Structs.AnnotCalloutLine,+    module GI.Poppler.Structs.AnnotMapping  ,+    module GI.Poppler.Structs.Color         ,+    module GI.Poppler.Structs.Dest          ,+    module GI.Poppler.Structs.FontsIter     ,+    module GI.Poppler.Structs.FormFieldMapping,+    module GI.Poppler.Structs.ImageMapping  ,+    module GI.Poppler.Structs.IndexIter     ,+    module GI.Poppler.Structs.LayersIter    ,+    module GI.Poppler.Structs.LinkMapping   ,+    module GI.Poppler.Structs.PageTransition,+    module GI.Poppler.Structs.Point         ,+    module GI.Poppler.Structs.Quadrilateral ,+    module GI.Poppler.Structs.Rectangle     ,+    module GI.Poppler.Structs.StructureElementIter,+    module GI.Poppler.Structs.TextAttributes,+    module GI.Poppler.Structs.TextSpan      ,+++    ) where++import GI.Poppler.Structs.ActionAny+import GI.Poppler.Structs.ActionGotoDest+import GI.Poppler.Structs.ActionGotoRemote+import GI.Poppler.Structs.ActionJavascript+import GI.Poppler.Structs.ActionLaunch+import GI.Poppler.Structs.ActionLayer+import GI.Poppler.Structs.ActionMovie+import GI.Poppler.Structs.ActionNamed+import GI.Poppler.Structs.ActionOCGState+import GI.Poppler.Structs.ActionRendition+import GI.Poppler.Structs.ActionUri+import GI.Poppler.Structs.AnnotCalloutLine+import GI.Poppler.Structs.AnnotMapping+import GI.Poppler.Structs.Color+import GI.Poppler.Structs.Dest+import GI.Poppler.Structs.FontsIter+import GI.Poppler.Structs.FormFieldMapping+import GI.Poppler.Structs.ImageMapping+import GI.Poppler.Structs.IndexIter+import GI.Poppler.Structs.LayersIter+import GI.Poppler.Structs.LinkMapping+import GI.Poppler.Structs.PageTransition+import GI.Poppler.Structs.Point+import GI.Poppler.Structs.Quadrilateral+import GI.Poppler.Structs.Rectangle+import GI.Poppler.Structs.StructureElementIter+import GI.Poppler.Structs.TextAttributes+import GI.Poppler.Structs.TextSpan++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Poppler.Types+import GI.Poppler.Callbacks++
+ GI/Poppler/Structs/ActionAny.hs view
@@ -0,0 +1,55 @@++{- |+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.ActionAny+    ( ++-- * Exported types+    ActionAny(..)                           ,+    noActionAny                             ,+++ -- * Properties+-- ** Title+    actionAnyReadTitle                      ,+++-- ** Type+    actionAnyReadType                       ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Poppler.Types+import GI.Poppler.Callbacks++newtype ActionAny = ActionAny (ForeignPtr ActionAny)+noActionAny :: Maybe ActionAny+noActionAny = Nothing++actionAnyReadType :: ActionAny -> IO ActionType+actionAnyReadType s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO CUInt+    let val' = (toEnum . fromIntegral) val+    return val'++actionAnyReadTitle :: ActionAny -> IO T.Text+actionAnyReadTitle s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 8) :: IO CString+    val' <- cstringToText val+    return val'++
+ GI/Poppler/Structs/ActionAny.hs-boot view
@@ -0,0 +1,10 @@+module GI.Poppler.Structs.ActionAny where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype ActionAny = ActionAny (ForeignPtr ActionAny)
+ GI/Poppler/Structs/ActionGotoDest.hs view
@@ -0,0 +1,65 @@++{- |+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.ActionGotoDest+    ( ++-- * Exported types+    ActionGotoDest(..)                      ,+    noActionGotoDest                        ,+++ -- * Properties+-- ** Dest+    actionGotoDestReadDest                  ,+++-- ** Title+    actionGotoDestReadTitle                 ,+++-- ** Type+    actionGotoDestReadType                  ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Poppler.Types+import GI.Poppler.Callbacks++newtype ActionGotoDest = ActionGotoDest (ForeignPtr ActionGotoDest)+noActionGotoDest :: Maybe ActionGotoDest+noActionGotoDest = Nothing++actionGotoDestReadType :: ActionGotoDest -> IO ActionType+actionGotoDestReadType s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO CUInt+    let val' = (toEnum . fromIntegral) val+    return val'++actionGotoDestReadTitle :: ActionGotoDest -> IO T.Text+actionGotoDestReadTitle s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 8) :: IO CString+    val' <- cstringToText val+    return val'++actionGotoDestReadDest :: ActionGotoDest -> IO Dest+actionGotoDestReadDest s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 16) :: IO (Ptr Dest)+    val' <- (newBoxed Dest) val+    return val'++
+ GI/Poppler/Structs/ActionGotoDest.hs-boot view
@@ -0,0 +1,10 @@+module GI.Poppler.Structs.ActionGotoDest where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype ActionGotoDest = ActionGotoDest (ForeignPtr ActionGotoDest)
+ GI/Poppler/Structs/ActionGotoRemote.hs view
@@ -0,0 +1,75 @@++{- |+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.ActionGotoRemote+    ( ++-- * Exported types+    ActionGotoRemote(..)                    ,+    noActionGotoRemote                      ,+++ -- * Properties+-- ** Dest+    actionGotoRemoteReadDest                ,+++-- ** FileName+    actionGotoRemoteReadFileName            ,+++-- ** Title+    actionGotoRemoteReadTitle               ,+++-- ** Type+    actionGotoRemoteReadType                ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Poppler.Types+import GI.Poppler.Callbacks++newtype ActionGotoRemote = ActionGotoRemote (ForeignPtr ActionGotoRemote)+noActionGotoRemote :: Maybe ActionGotoRemote+noActionGotoRemote = Nothing++actionGotoRemoteReadType :: ActionGotoRemote -> IO ActionType+actionGotoRemoteReadType s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO CUInt+    let val' = (toEnum . fromIntegral) val+    return val'++actionGotoRemoteReadTitle :: ActionGotoRemote -> IO T.Text+actionGotoRemoteReadTitle s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 8) :: IO CString+    val' <- cstringToText val+    return val'++actionGotoRemoteReadFileName :: ActionGotoRemote -> IO T.Text+actionGotoRemoteReadFileName s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 16) :: IO CString+    val' <- cstringToText val+    return val'++actionGotoRemoteReadDest :: ActionGotoRemote -> IO Dest+actionGotoRemoteReadDest s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 24) :: IO (Ptr Dest)+    val' <- (newBoxed Dest) val+    return val'++
+ GI/Poppler/Structs/ActionGotoRemote.hs-boot view
@@ -0,0 +1,10 @@+module GI.Poppler.Structs.ActionGotoRemote where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype ActionGotoRemote = ActionGotoRemote (ForeignPtr ActionGotoRemote)
+ GI/Poppler/Structs/ActionJavascript.hs view
@@ -0,0 +1,65 @@++{- |+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.ActionJavascript+    ( ++-- * Exported types+    ActionJavascript(..)                    ,+    noActionJavascript                      ,+++ -- * Properties+-- ** Script+    actionJavascriptReadScript              ,+++-- ** Title+    actionJavascriptReadTitle               ,+++-- ** Type+    actionJavascriptReadType                ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Poppler.Types+import GI.Poppler.Callbacks++newtype ActionJavascript = ActionJavascript (ForeignPtr ActionJavascript)+noActionJavascript :: Maybe ActionJavascript+noActionJavascript = Nothing++actionJavascriptReadType :: ActionJavascript -> IO ActionType+actionJavascriptReadType s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO CUInt+    let val' = (toEnum . fromIntegral) val+    return val'++actionJavascriptReadTitle :: ActionJavascript -> IO T.Text+actionJavascriptReadTitle s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 8) :: IO CString+    val' <- cstringToText val+    return val'++actionJavascriptReadScript :: ActionJavascript -> IO T.Text+actionJavascriptReadScript s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 16) :: IO CString+    val' <- cstringToText val+    return val'++
+ GI/Poppler/Structs/ActionJavascript.hs-boot view
@@ -0,0 +1,10 @@+module GI.Poppler.Structs.ActionJavascript where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype ActionJavascript = ActionJavascript (ForeignPtr ActionJavascript)
+ GI/Poppler/Structs/ActionLaunch.hs view
@@ -0,0 +1,75 @@++{- |+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.ActionLaunch+    ( ++-- * Exported types+    ActionLaunch(..)                        ,+    noActionLaunch                          ,+++ -- * Properties+-- ** FileName+    actionLaunchReadFileName                ,+++-- ** Params+    actionLaunchReadParams                  ,+++-- ** Title+    actionLaunchReadTitle                   ,+++-- ** Type+    actionLaunchReadType                    ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Poppler.Types+import GI.Poppler.Callbacks++newtype ActionLaunch = ActionLaunch (ForeignPtr ActionLaunch)+noActionLaunch :: Maybe ActionLaunch+noActionLaunch = Nothing++actionLaunchReadType :: ActionLaunch -> IO ActionType+actionLaunchReadType s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO CUInt+    let val' = (toEnum . fromIntegral) val+    return val'++actionLaunchReadTitle :: ActionLaunch -> IO T.Text+actionLaunchReadTitle s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 8) :: IO CString+    val' <- cstringToText val+    return val'++actionLaunchReadFileName :: ActionLaunch -> IO T.Text+actionLaunchReadFileName s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 16) :: IO CString+    val' <- cstringToText val+    return val'++actionLaunchReadParams :: ActionLaunch -> IO T.Text+actionLaunchReadParams s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 24) :: IO CString+    val' <- cstringToText val+    return val'++
+ GI/Poppler/Structs/ActionLaunch.hs-boot view
@@ -0,0 +1,10 @@+module GI.Poppler.Structs.ActionLaunch where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype ActionLaunch = ActionLaunch (ForeignPtr ActionLaunch)
+ GI/Poppler/Structs/ActionLayer.hs view
@@ -0,0 +1,57 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++Action to perform over a list of layers+-}++module GI.Poppler.Structs.ActionLayer+    ( ++-- * Exported types+    ActionLayer(..)                         ,+    noActionLayer                           ,+++ -- * Properties+-- ** Action+    actionLayerReadAction                   ,+++-- ** Layers+    actionLayerReadLayers                   ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Poppler.Types+import GI.Poppler.Callbacks++newtype ActionLayer = ActionLayer (ForeignPtr ActionLayer)+noActionLayer :: Maybe ActionLayer+noActionLayer = Nothing++actionLayerReadAction :: ActionLayer -> IO ActionLayerAction+actionLayerReadAction s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO CUInt+    let val' = (toEnum . fromIntegral) val+    return val'++actionLayerReadLayers :: ActionLayer -> IO ([Ptr ()])+actionLayerReadLayers s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 8) :: IO (Ptr (GList (Ptr ())))+    val' <- unpackGList val+    return val'++
+ GI/Poppler/Structs/ActionLayer.hs-boot view
@@ -0,0 +1,10 @@+module GI.Poppler.Structs.ActionLayer where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype ActionLayer = ActionLayer (ForeignPtr ActionLayer)
+ GI/Poppler/Structs/ActionMovie.hs view
@@ -0,0 +1,75 @@++{- |+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.ActionMovie+    ( ++-- * Exported types+    ActionMovie(..)                         ,+    noActionMovie                           ,+++ -- * Properties+-- ** Movie+    actionMovieReadMovie                    ,+++-- ** Operation+    actionMovieReadOperation                ,+++-- ** Title+    actionMovieReadTitle                    ,+++-- ** Type+    actionMovieReadType                     ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Poppler.Types+import GI.Poppler.Callbacks++newtype ActionMovie = ActionMovie (ForeignPtr ActionMovie)+noActionMovie :: Maybe ActionMovie+noActionMovie = Nothing++actionMovieReadType :: ActionMovie -> IO ActionType+actionMovieReadType s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO CUInt+    let val' = (toEnum . fromIntegral) val+    return val'++actionMovieReadTitle :: ActionMovie -> IO T.Text+actionMovieReadTitle s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 8) :: IO CString+    val' <- cstringToText val+    return val'++actionMovieReadOperation :: ActionMovie -> IO ActionMovieOperation+actionMovieReadOperation s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 16) :: IO CUInt+    let val' = (toEnum . fromIntegral) val+    return val'++actionMovieReadMovie :: ActionMovie -> IO Movie+actionMovieReadMovie s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 24) :: IO (Ptr Movie)+    val' <- (newObject Movie) val+    return val'++
+ GI/Poppler/Structs/ActionMovie.hs-boot view
@@ -0,0 +1,10 @@+module GI.Poppler.Structs.ActionMovie where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype ActionMovie = ActionMovie (ForeignPtr ActionMovie)
+ GI/Poppler/Structs/ActionNamed.hs view
@@ -0,0 +1,65 @@++{- |+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.ActionNamed+    ( ++-- * Exported types+    ActionNamed(..)                         ,+    noActionNamed                           ,+++ -- * Properties+-- ** NamedDest+    actionNamedReadNamedDest                ,+++-- ** Title+    actionNamedReadTitle                    ,+++-- ** Type+    actionNamedReadType                     ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Poppler.Types+import GI.Poppler.Callbacks++newtype ActionNamed = ActionNamed (ForeignPtr ActionNamed)+noActionNamed :: Maybe ActionNamed+noActionNamed = Nothing++actionNamedReadType :: ActionNamed -> IO ActionType+actionNamedReadType s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO CUInt+    let val' = (toEnum . fromIntegral) val+    return val'++actionNamedReadTitle :: ActionNamed -> IO T.Text+actionNamedReadTitle s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 8) :: IO CString+    val' <- cstringToText val+    return val'++actionNamedReadNamedDest :: ActionNamed -> IO T.Text+actionNamedReadNamedDest s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 16) :: IO CString+    val' <- cstringToText val+    return val'++
+ GI/Poppler/Structs/ActionNamed.hs-boot view
@@ -0,0 +1,10 @@+module GI.Poppler.Structs.ActionNamed where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype ActionNamed = ActionNamed (ForeignPtr ActionNamed)
+ GI/Poppler/Structs/ActionOCGState.hs view
@@ -0,0 +1,65 @@++{- |+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.ActionOCGState+    ( ++-- * Exported types+    ActionOCGState(..)                      ,+    noActionOCGState                        ,+++ -- * Properties+-- ** StateList+    actionOCGStateReadStateList             ,+++-- ** Title+    actionOCGStateReadTitle                 ,+++-- ** Type+    actionOCGStateReadType                  ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Poppler.Types+import GI.Poppler.Callbacks++newtype ActionOCGState = ActionOCGState (ForeignPtr ActionOCGState)+noActionOCGState :: Maybe ActionOCGState+noActionOCGState = Nothing++actionOCGStateReadType :: ActionOCGState -> IO ActionType+actionOCGStateReadType s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO CUInt+    let val' = (toEnum . fromIntegral) val+    return val'++actionOCGStateReadTitle :: ActionOCGState -> IO T.Text+actionOCGStateReadTitle s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 8) :: IO CString+    val' <- cstringToText val+    return val'++actionOCGStateReadStateList :: ActionOCGState -> IO ([Ptr ()])+actionOCGStateReadStateList s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 16) :: IO (Ptr (GList (Ptr ())))+    val' <- unpackGList val+    return val'++
+ GI/Poppler/Structs/ActionOCGState.hs-boot view
@@ -0,0 +1,10 @@+module GI.Poppler.Structs.ActionOCGState where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype ActionOCGState = ActionOCGState (ForeignPtr ActionOCGState)
+ GI/Poppler/Structs/ActionRendition.hs view
@@ -0,0 +1,74 @@++{- |+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.ActionRendition+    ( ++-- * Exported types+    ActionRendition(..)                     ,+    noActionRendition                       ,+++ -- * Properties+-- ** Media+    actionRenditionReadMedia                ,+++-- ** Op+    actionRenditionReadOp                   ,+++-- ** Title+    actionRenditionReadTitle                ,+++-- ** Type+    actionRenditionReadType                 ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Poppler.Types+import GI.Poppler.Callbacks++newtype ActionRendition = ActionRendition (ForeignPtr ActionRendition)+noActionRendition :: Maybe ActionRendition+noActionRendition = Nothing++actionRenditionReadType :: ActionRendition -> IO ActionType+actionRenditionReadType s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO CUInt+    let val' = (toEnum . fromIntegral) val+    return val'++actionRenditionReadTitle :: ActionRendition -> IO T.Text+actionRenditionReadTitle s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 8) :: IO CString+    val' <- cstringToText val+    return val'++actionRenditionReadOp :: ActionRendition -> IO Int32+actionRenditionReadOp s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 16) :: IO Int32+    return val++actionRenditionReadMedia :: ActionRendition -> IO Media+actionRenditionReadMedia s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 24) :: IO (Ptr Media)+    val' <- (newObject Media) val+    return val'++
+ GI/Poppler/Structs/ActionRendition.hs-boot view
@@ -0,0 +1,10 @@+module GI.Poppler.Structs.ActionRendition where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype ActionRendition = ActionRendition (ForeignPtr ActionRendition)
+ GI/Poppler/Structs/ActionUri.hs view
@@ -0,0 +1,65 @@++{- |+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.ActionUri+    ( ++-- * Exported types+    ActionUri(..)                           ,+    noActionUri                             ,+++ -- * Properties+-- ** Title+    actionUriReadTitle                      ,+++-- ** Type+    actionUriReadType                       ,+++-- ** Uri+    actionUriReadUri                        ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Poppler.Types+import GI.Poppler.Callbacks++newtype ActionUri = ActionUri (ForeignPtr ActionUri)+noActionUri :: Maybe ActionUri+noActionUri = Nothing++actionUriReadType :: ActionUri -> IO ActionType+actionUriReadType s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO CUInt+    let val' = (toEnum . fromIntegral) val+    return val'++actionUriReadTitle :: ActionUri -> IO T.Text+actionUriReadTitle s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 8) :: IO CString+    val' <- cstringToText val+    return val'++actionUriReadUri :: ActionUri -> IO T.Text+actionUriReadUri s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 16) :: IO CString+    val' <- cstringToText val+    return val'++
+ GI/Poppler/Structs/ActionUri.hs-boot view
@@ -0,0 +1,10 @@+module GI.Poppler.Structs.ActionUri where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype ActionUri = ActionUri (ForeignPtr ActionUri)
+ GI/Poppler/Structs/AnnotCalloutLine.hs view
@@ -0,0 +1,198 @@++{- |+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(..)                    ,+    noAnnotCalloutLine                      ,+++ -- * Methods+-- ** annotCalloutLineCopy+    annotCalloutLineCopy                    ,+++-- ** annotCalloutLineFree+    annotCalloutLineFree                    ,+++-- ** annotCalloutLineNew+    annotCalloutLineNew                     ,+++++ -- * Properties+-- ** Multiline+    annotCalloutLineReadMultiline           ,+++-- ** X1+    annotCalloutLineReadX1                  ,+++-- ** X2+    annotCalloutLineReadX2                  ,+++-- ** X3+    annotCalloutLineReadX3                  ,+++-- ** Y1+    annotCalloutLineReadY1                  ,+++-- ** Y2+    annotCalloutLineReadY2                  ,+++-- ** Y3+    annotCalloutLineReadY3                  ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Poppler.Types+import GI.Poppler.Callbacks++newtype AnnotCalloutLine = AnnotCalloutLine (ForeignPtr 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++noAnnotCalloutLine :: Maybe AnnotCalloutLine+noAnnotCalloutLine = Nothing++annotCalloutLineReadMultiline :: AnnotCalloutLine -> IO Bool+annotCalloutLineReadMultiline s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO CInt+    let val' = (/= 0) val+    return val'++annotCalloutLineReadX1 :: AnnotCalloutLine -> IO Double+annotCalloutLineReadX1 s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 8) :: IO CDouble+    let val' = realToFrac val+    return val'++annotCalloutLineReadY1 :: AnnotCalloutLine -> IO Double+annotCalloutLineReadY1 s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 16) :: IO CDouble+    let val' = realToFrac val+    return val'++annotCalloutLineReadX2 :: AnnotCalloutLine -> IO Double+annotCalloutLineReadX2 s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 24) :: IO CDouble+    let val' = realToFrac val+    return val'++annotCalloutLineReadY2 :: AnnotCalloutLine -> IO Double+annotCalloutLineReadY2 s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 32) :: IO CDouble+    let val' = realToFrac val+    return val'++annotCalloutLineReadX3 :: AnnotCalloutLine -> IO Double+annotCalloutLineReadX3 s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 40) :: IO CDouble+    let val' = realToFrac val+    return val'++annotCalloutLineReadY3 :: AnnotCalloutLine -> IO Double+annotCalloutLineReadY3 s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 48) :: IO CDouble+    let val' = realToFrac val+    return val'++-- method AnnotCalloutLine::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Poppler" "AnnotCalloutLine"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_annot_callout_line_new" poppler_annot_callout_line_new :: +    IO (Ptr AnnotCalloutLine)+++annotCalloutLineNew ::+    (MonadIO m) =>+    m AnnotCalloutLine+annotCalloutLineNew  = liftIO $ do+    result <- poppler_annot_callout_line_new+    checkUnexpectedReturnNULL "poppler_annot_callout_line_new" result+    result' <- (wrapBoxed AnnotCalloutLine) result+    return result'++-- method AnnotCalloutLine::copy+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotCalloutLine", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotCalloutLine", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "AnnotCalloutLine"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_annot_callout_line_copy" poppler_annot_callout_line_copy :: +    Ptr AnnotCalloutLine ->                 -- _obj : TInterface "Poppler" "AnnotCalloutLine"+    IO (Ptr AnnotCalloutLine)+++annotCalloutLineCopy ::+    (MonadIO m) =>+    AnnotCalloutLine ->                     -- _obj+    m AnnotCalloutLine+annotCalloutLineCopy _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- poppler_annot_callout_line_copy _obj'+    checkUnexpectedReturnNULL "poppler_annot_callout_line_copy" result+    result' <- (wrapBoxed AnnotCalloutLine) result+    touchManagedPtr _obj+    return result'++-- method AnnotCalloutLine::free+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotCalloutLine", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotCalloutLine", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_annot_callout_line_free" poppler_annot_callout_line_free :: +    Ptr AnnotCalloutLine ->                 -- _obj : TInterface "Poppler" "AnnotCalloutLine"+    IO ()+++annotCalloutLineFree ::+    (MonadIO m) =>+    AnnotCalloutLine ->                     -- _obj+    m ()+annotCalloutLineFree _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    poppler_annot_callout_line_free _obj'+    touchManagedPtr _obj+    return ()++
+ GI/Poppler/Structs/AnnotCalloutLine.hs-boot view
@@ -0,0 +1,11 @@+module GI.Poppler.Structs.AnnotCalloutLine where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype AnnotCalloutLine = AnnotCalloutLine (ForeignPtr AnnotCalloutLine)+instance BoxedObject AnnotCalloutLine where
+ GI/Poppler/Structs/AnnotMapping.hs view
@@ -0,0 +1,151 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++A #PopplerAnnotMapping structure represents the location+of @annot on the page+-}++module GI.Poppler.Structs.AnnotMapping+    ( ++-- * Exported types+    AnnotMapping(..)                        ,+    noAnnotMapping                          ,+++ -- * Methods+-- ** annotMappingCopy+    annotMappingCopy                        ,+++-- ** annotMappingFree+    annotMappingFree                        ,+++-- ** annotMappingNew+    annotMappingNew                         ,+++++ -- * Properties+-- ** Annot+    annotMappingReadAnnot                   ,+++-- ** Area+    annotMappingReadArea                    ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Poppler.Types+import GI.Poppler.Callbacks++newtype AnnotMapping = AnnotMapping (ForeignPtr AnnotMapping)+foreign import ccall "poppler_annot_mapping_get_type" c_poppler_annot_mapping_get_type :: +    IO GType++instance BoxedObject AnnotMapping where+    boxedType _ = c_poppler_annot_mapping_get_type++noAnnotMapping :: Maybe AnnotMapping+noAnnotMapping = Nothing++annotMappingReadArea :: AnnotMapping -> IO Rectangle+annotMappingReadArea s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO (Ptr Rectangle)+    val' <- (newBoxed Rectangle) val+    return val'++annotMappingReadAnnot :: AnnotMapping -> IO Annot+annotMappingReadAnnot s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 32) :: IO (Ptr Annot)+    val' <- (newObject Annot) val+    return val'++-- method AnnotMapping::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Poppler" "AnnotMapping"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_annot_mapping_new" poppler_annot_mapping_new :: +    IO (Ptr AnnotMapping)+++annotMappingNew ::+    (MonadIO m) =>+    m AnnotMapping+annotMappingNew  = liftIO $ do+    result <- poppler_annot_mapping_new+    checkUnexpectedReturnNULL "poppler_annot_mapping_new" result+    result' <- (wrapBoxed AnnotMapping) result+    return result'++-- method AnnotMapping::copy+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotMapping", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotMapping", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "AnnotMapping"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_annot_mapping_copy" poppler_annot_mapping_copy :: +    Ptr AnnotMapping ->                     -- _obj : TInterface "Poppler" "AnnotMapping"+    IO (Ptr AnnotMapping)+++annotMappingCopy ::+    (MonadIO m) =>+    AnnotMapping ->                         -- _obj+    m AnnotMapping+annotMappingCopy _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- poppler_annot_mapping_copy _obj'+    checkUnexpectedReturnNULL "poppler_annot_mapping_copy" result+    result' <- (wrapBoxed AnnotMapping) result+    touchManagedPtr _obj+    return result'++-- method AnnotMapping::free+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotMapping", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "AnnotMapping", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_annot_mapping_free" poppler_annot_mapping_free :: +    Ptr AnnotMapping ->                     -- _obj : TInterface "Poppler" "AnnotMapping"+    IO ()+++annotMappingFree ::+    (MonadIO m) =>+    AnnotMapping ->                         -- _obj+    m ()+annotMappingFree _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    poppler_annot_mapping_free _obj'+    touchManagedPtr _obj+    return ()++
+ GI/Poppler/Structs/AnnotMapping.hs-boot view
@@ -0,0 +1,11 @@+module GI.Poppler.Structs.AnnotMapping where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype AnnotMapping = AnnotMapping (ForeignPtr AnnotMapping)+instance BoxedObject AnnotMapping where
+ GI/Poppler/Structs/Color.hs view
@@ -0,0 +1,158 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++A #PopplerColor describes a RGB color. Color components+are values between 0 and 65535+-}++module GI.Poppler.Structs.Color+    ( ++-- * Exported types+    Color(..)                               ,+    noColor                                 ,+++ -- * Methods+-- ** colorCopy+    colorCopy                               ,+++-- ** colorFree+    colorFree                               ,+++-- ** colorNew+    colorNew                                ,+++++ -- * Properties+-- ** Blue+    colorReadBlue                           ,+++-- ** Green+    colorReadGreen                          ,+++-- ** Red+    colorReadRed                            ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Poppler.Types+import GI.Poppler.Callbacks++newtype Color = Color (ForeignPtr Color)+foreign import ccall "poppler_color_get_type" c_poppler_color_get_type :: +    IO GType++instance BoxedObject Color where+    boxedType _ = c_poppler_color_get_type++noColor :: Maybe Color+noColor = Nothing++colorReadRed :: Color -> IO Word16+colorReadRed s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO Word16+    return val++colorReadGreen :: Color -> IO Word16+colorReadGreen s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 2) :: IO Word16+    return val++colorReadBlue :: Color -> IO Word16+colorReadBlue s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 4) :: IO Word16+    return val++-- method Color::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Poppler" "Color"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_color_new" poppler_color_new :: +    IO (Ptr Color)+++colorNew ::+    (MonadIO m) =>+    m Color+colorNew  = liftIO $ do+    result <- poppler_color_new+    checkUnexpectedReturnNULL "poppler_color_new" result+    result' <- (wrapBoxed Color) result+    return result'++-- method Color::copy+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Color", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Color", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "Color"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_color_copy" poppler_color_copy :: +    Ptr Color ->                            -- _obj : TInterface "Poppler" "Color"+    IO (Ptr Color)+++colorCopy ::+    (MonadIO m) =>+    Color ->                                -- _obj+    m Color+colorCopy _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- poppler_color_copy _obj'+    checkUnexpectedReturnNULL "poppler_color_copy" result+    result' <- (wrapBoxed Color) result+    touchManagedPtr _obj+    return result'++-- method Color::free+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Color", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Color", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_color_free" poppler_color_free :: +    Ptr Color ->                            -- _obj : TInterface "Poppler" "Color"+    IO ()+++colorFree ::+    (MonadIO m) =>+    Color ->                                -- _obj+    m ()+colorFree _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    poppler_color_free _obj'+    touchManagedPtr _obj+    return ()++
+ GI/Poppler/Structs/Color.hs-boot view
@@ -0,0 +1,11 @@+module GI.Poppler.Structs.Color where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype Color = Color (ForeignPtr Color)+instance BoxedObject Color where
+ GI/Poppler/Structs/Dest.hs view
@@ -0,0 +1,210 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++Data structure for holding a destination+-}++module GI.Poppler.Structs.Dest+    ( ++-- * Exported types+    Dest(..)                                ,+    noDest                                  ,+++ -- * Methods+-- ** destCopy+    destCopy                                ,+++-- ** destFree+    destFree                                ,+++++ -- * Properties+-- ** Bottom+    destReadBottom                          ,+++-- ** ChangeLeft+    destReadChangeLeft                      ,+++-- ** ChangeTop+    destReadChangeTop                       ,+++-- ** ChangeZoom+    destReadChangeZoom                      ,+++-- ** Left+    destReadLeft                            ,+++-- ** NamedDest+    destReadNamedDest                       ,+++-- ** PageNum+    destReadPageNum                         ,+++-- ** Right+    destReadRight                           ,+++-- ** Top+    destReadTop                             ,+++-- ** Type+    destReadType                            ,+++-- ** Zoom+    destReadZoom                            ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Poppler.Types+import GI.Poppler.Callbacks++newtype Dest = Dest (ForeignPtr Dest)+foreign import ccall "poppler_dest_get_type" c_poppler_dest_get_type :: +    IO GType++instance BoxedObject Dest where+    boxedType _ = c_poppler_dest_get_type++noDest :: Maybe Dest+noDest = Nothing++destReadType :: Dest -> IO DestType+destReadType s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO CUInt+    let val' = (toEnum . fromIntegral) val+    return val'++destReadPageNum :: Dest -> IO Int32+destReadPageNum s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 4) :: IO Int32+    return val++destReadLeft :: Dest -> IO Double+destReadLeft s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 8) :: IO CDouble+    let val' = realToFrac val+    return val'++destReadBottom :: Dest -> IO Double+destReadBottom s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 16) :: IO CDouble+    let val' = realToFrac val+    return val'++destReadRight :: Dest -> IO Double+destReadRight s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 24) :: IO CDouble+    let val' = realToFrac val+    return val'++destReadTop :: Dest -> IO Double+destReadTop s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 32) :: IO CDouble+    let val' = realToFrac val+    return val'++destReadZoom :: Dest -> IO Double+destReadZoom s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 40) :: IO CDouble+    let val' = realToFrac val+    return val'++destReadNamedDest :: Dest -> IO T.Text+destReadNamedDest s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 48) :: IO CString+    val' <- cstringToText val+    return val'++destReadChangeLeft :: Dest -> IO Word32+destReadChangeLeft s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 56) :: IO Word32+    return val++destReadChangeTop :: Dest -> IO Word32+destReadChangeTop s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 60) :: IO Word32+    return val++destReadChangeZoom :: Dest -> IO Word32+destReadChangeZoom s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 64) :: IO Word32+    return val++-- method Dest::copy+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Dest", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Dest", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "Dest"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_dest_copy" poppler_dest_copy :: +    Ptr Dest ->                             -- _obj : TInterface "Poppler" "Dest"+    IO (Ptr Dest)+++destCopy ::+    (MonadIO m) =>+    Dest ->                                 -- _obj+    m Dest+destCopy _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- poppler_dest_copy _obj'+    checkUnexpectedReturnNULL "poppler_dest_copy" result+    result' <- (wrapBoxed Dest) result+    touchManagedPtr _obj+    return result'++-- method Dest::free+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Dest", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Dest", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_dest_free" poppler_dest_free :: +    Ptr Dest ->                             -- _obj : TInterface "Poppler" "Dest"+    IO ()+++destFree ::+    (MonadIO m) =>+    Dest ->                                 -- _obj+    m ()+destFree _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    poppler_dest_free _obj'+    touchManagedPtr _obj+    return ()++
+ GI/Poppler/Structs/Dest.hs-boot view
@@ -0,0 +1,11 @@+module GI.Poppler.Structs.Dest where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype Dest = Dest (ForeignPtr Dest)+instance BoxedObject Dest where
+ GI/Poppler/Structs/FontsIter.hs view
@@ -0,0 +1,365 @@++{- |+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.FontsIter+    ( ++-- * Exported types+    FontsIter(..)                           ,+    noFontsIter                             ,+++ -- * Methods+-- ** fontsIterCopy+    fontsIterCopy                           ,+++-- ** fontsIterFree+    fontsIterFree                           ,+++-- ** fontsIterGetEncoding+    fontsIterGetEncoding                    ,+++-- ** fontsIterGetFileName+    fontsIterGetFileName                    ,+++-- ** fontsIterGetFontType+    fontsIterGetFontType                    ,+++-- ** fontsIterGetFullName+    fontsIterGetFullName                    ,+++-- ** fontsIterGetName+    fontsIterGetName                        ,+++-- ** fontsIterGetSubstituteName+    fontsIterGetSubstituteName              ,+++-- ** fontsIterIsEmbedded+    fontsIterIsEmbedded                     ,+++-- ** fontsIterIsSubset+    fontsIterIsSubset                       ,+++-- ** fontsIterNext+    fontsIterNext                           ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Poppler.Types+import GI.Poppler.Callbacks++newtype FontsIter = FontsIter (ForeignPtr FontsIter)+foreign import ccall "poppler_fonts_iter_get_type" c_poppler_fonts_iter_get_type :: +    IO GType++instance BoxedObject FontsIter where+    boxedType _ = c_poppler_fonts_iter_get_type++noFontsIter :: Maybe FontsIter+noFontsIter = Nothing++-- method FontsIter::copy+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "FontsIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "FontsIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "FontsIter"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_fonts_iter_copy" poppler_fonts_iter_copy :: +    Ptr FontsIter ->                        -- _obj : TInterface "Poppler" "FontsIter"+    IO (Ptr FontsIter)+++fontsIterCopy ::+    (MonadIO m) =>+    FontsIter ->                            -- _obj+    m FontsIter+fontsIterCopy _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- poppler_fonts_iter_copy _obj'+    checkUnexpectedReturnNULL "poppler_fonts_iter_copy" result+    result' <- (wrapBoxed FontsIter) result+    touchManagedPtr _obj+    return result'++-- method FontsIter::free+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "FontsIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "FontsIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_fonts_iter_free" poppler_fonts_iter_free :: +    Ptr FontsIter ->                        -- _obj : TInterface "Poppler" "FontsIter"+    IO ()+++fontsIterFree ::+    (MonadIO m) =>+    FontsIter ->                            -- _obj+    m ()+fontsIterFree _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    poppler_fonts_iter_free _obj'+    touchManagedPtr _obj+    return ()++-- method FontsIter::get_encoding+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "FontsIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "FontsIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "poppler_fonts_iter_get_encoding" poppler_fonts_iter_get_encoding :: +    Ptr FontsIter ->                        -- _obj : TInterface "Poppler" "FontsIter"+    IO CString+++fontsIterGetEncoding ::+    (MonadIO m) =>+    FontsIter ->                            -- _obj+    m T.Text+fontsIterGetEncoding _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- poppler_fonts_iter_get_encoding _obj'+    checkUnexpectedReturnNULL "poppler_fonts_iter_get_encoding" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method FontsIter::get_file_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "FontsIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "FontsIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "poppler_fonts_iter_get_file_name" poppler_fonts_iter_get_file_name :: +    Ptr FontsIter ->                        -- _obj : TInterface "Poppler" "FontsIter"+    IO CString+++fontsIterGetFileName ::+    (MonadIO m) =>+    FontsIter ->                            -- _obj+    m T.Text+fontsIterGetFileName _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- poppler_fonts_iter_get_file_name _obj'+    checkUnexpectedReturnNULL "poppler_fonts_iter_get_file_name" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method FontsIter::get_font_type+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "FontsIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "FontsIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "FontType"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_fonts_iter_get_font_type" poppler_fonts_iter_get_font_type :: +    Ptr FontsIter ->                        -- _obj : TInterface "Poppler" "FontsIter"+    IO CUInt+++fontsIterGetFontType ::+    (MonadIO m) =>+    FontsIter ->                            -- _obj+    m FontType+fontsIterGetFontType _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- poppler_fonts_iter_get_font_type _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++-- method FontsIter::get_full_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "FontsIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "FontsIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "poppler_fonts_iter_get_full_name" poppler_fonts_iter_get_full_name :: +    Ptr FontsIter ->                        -- _obj : TInterface "Poppler" "FontsIter"+    IO CString+++fontsIterGetFullName ::+    (MonadIO m) =>+    FontsIter ->                            -- _obj+    m T.Text+fontsIterGetFullName _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- poppler_fonts_iter_get_full_name _obj'+    checkUnexpectedReturnNULL "poppler_fonts_iter_get_full_name" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method FontsIter::get_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "FontsIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "FontsIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "poppler_fonts_iter_get_name" poppler_fonts_iter_get_name :: +    Ptr FontsIter ->                        -- _obj : TInterface "Poppler" "FontsIter"+    IO CString+++fontsIterGetName ::+    (MonadIO m) =>+    FontsIter ->                            -- _obj+    m T.Text+fontsIterGetName _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- poppler_fonts_iter_get_name _obj'+    checkUnexpectedReturnNULL "poppler_fonts_iter_get_name" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method FontsIter::get_substitute_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "FontsIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "FontsIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "poppler_fonts_iter_get_substitute_name" poppler_fonts_iter_get_substitute_name :: +    Ptr FontsIter ->                        -- _obj : TInterface "Poppler" "FontsIter"+    IO CString+++fontsIterGetSubstituteName ::+    (MonadIO m) =>+    FontsIter ->                            -- _obj+    m T.Text+fontsIterGetSubstituteName _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- poppler_fonts_iter_get_substitute_name _obj'+    checkUnexpectedReturnNULL "poppler_fonts_iter_get_substitute_name" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method FontsIter::is_embedded+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "FontsIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "FontsIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "poppler_fonts_iter_is_embedded" poppler_fonts_iter_is_embedded :: +    Ptr FontsIter ->                        -- _obj : TInterface "Poppler" "FontsIter"+    IO CInt+++fontsIterIsEmbedded ::+    (MonadIO m) =>+    FontsIter ->                            -- _obj+    m Bool+fontsIterIsEmbedded _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- poppler_fonts_iter_is_embedded _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method FontsIter::is_subset+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "FontsIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "FontsIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "poppler_fonts_iter_is_subset" poppler_fonts_iter_is_subset :: +    Ptr FontsIter ->                        -- _obj : TInterface "Poppler" "FontsIter"+    IO CInt+++fontsIterIsSubset ::+    (MonadIO m) =>+    FontsIter ->                            -- _obj+    m Bool+fontsIterIsSubset _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- poppler_fonts_iter_is_subset _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method FontsIter::next+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "FontsIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "FontsIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "poppler_fonts_iter_next" poppler_fonts_iter_next :: +    Ptr FontsIter ->                        -- _obj : TInterface "Poppler" "FontsIter"+    IO CInt+++fontsIterNext ::+    (MonadIO m) =>+    FontsIter ->                            -- _obj+    m Bool+fontsIterNext _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- poppler_fonts_iter_next _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++
+ GI/Poppler/Structs/FontsIter.hs-boot view
@@ -0,0 +1,11 @@+module GI.Poppler.Structs.FontsIter where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype FontsIter = FontsIter (ForeignPtr FontsIter)+instance BoxedObject FontsIter where
+ GI/Poppler/Structs/FormFieldMapping.hs view
@@ -0,0 +1,151 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++A #PopplerFormFieldMapping structure represents the location+of @field on the page+-}++module GI.Poppler.Structs.FormFieldMapping+    ( ++-- * Exported types+    FormFieldMapping(..)                    ,+    noFormFieldMapping                      ,+++ -- * Methods+-- ** formFieldMappingCopy+    formFieldMappingCopy                    ,+++-- ** formFieldMappingFree+    formFieldMappingFree                    ,+++-- ** formFieldMappingNew+    formFieldMappingNew                     ,+++++ -- * Properties+-- ** Area+    formFieldMappingReadArea                ,+++-- ** Field+    formFieldMappingReadField               ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Poppler.Types+import GI.Poppler.Callbacks++newtype FormFieldMapping = FormFieldMapping (ForeignPtr FormFieldMapping)+foreign import ccall "poppler_form_field_mapping_get_type" c_poppler_form_field_mapping_get_type :: +    IO GType++instance BoxedObject FormFieldMapping where+    boxedType _ = c_poppler_form_field_mapping_get_type++noFormFieldMapping :: Maybe FormFieldMapping+noFormFieldMapping = Nothing++formFieldMappingReadArea :: FormFieldMapping -> IO Rectangle+formFieldMappingReadArea s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO (Ptr Rectangle)+    val' <- (newBoxed Rectangle) val+    return val'++formFieldMappingReadField :: FormFieldMapping -> IO FormField+formFieldMappingReadField s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 32) :: IO (Ptr FormField)+    val' <- (newObject FormField) val+    return val'++-- method FormFieldMapping::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Poppler" "FormFieldMapping"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_form_field_mapping_new" poppler_form_field_mapping_new :: +    IO (Ptr FormFieldMapping)+++formFieldMappingNew ::+    (MonadIO m) =>+    m FormFieldMapping+formFieldMappingNew  = liftIO $ do+    result <- poppler_form_field_mapping_new+    checkUnexpectedReturnNULL "poppler_form_field_mapping_new" result+    result' <- (wrapBoxed FormFieldMapping) result+    return result'++-- method FormFieldMapping::copy+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormFieldMapping", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormFieldMapping", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "FormFieldMapping"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_form_field_mapping_copy" poppler_form_field_mapping_copy :: +    Ptr FormFieldMapping ->                 -- _obj : TInterface "Poppler" "FormFieldMapping"+    IO (Ptr FormFieldMapping)+++formFieldMappingCopy ::+    (MonadIO m) =>+    FormFieldMapping ->                     -- _obj+    m FormFieldMapping+formFieldMappingCopy _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- poppler_form_field_mapping_copy _obj'+    checkUnexpectedReturnNULL "poppler_form_field_mapping_copy" result+    result' <- (wrapBoxed FormFieldMapping) result+    touchManagedPtr _obj+    return result'++-- method FormFieldMapping::free+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormFieldMapping", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "FormFieldMapping", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_form_field_mapping_free" poppler_form_field_mapping_free :: +    Ptr FormFieldMapping ->                 -- _obj : TInterface "Poppler" "FormFieldMapping"+    IO ()+++formFieldMappingFree ::+    (MonadIO m) =>+    FormFieldMapping ->                     -- _obj+    m ()+formFieldMappingFree _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    poppler_form_field_mapping_free _obj'+    touchManagedPtr _obj+    return ()++
+ GI/Poppler/Structs/FormFieldMapping.hs-boot view
@@ -0,0 +1,11 @@+module GI.Poppler.Structs.FormFieldMapping where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype FormFieldMapping = FormFieldMapping (ForeignPtr FormFieldMapping)+instance BoxedObject FormFieldMapping where
+ GI/Poppler/Structs/ImageMapping.hs view
@@ -0,0 +1,150 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++A #PopplerImageMapping structure represents the location+of an image on the page+-}++module GI.Poppler.Structs.ImageMapping+    ( ++-- * Exported types+    ImageMapping(..)                        ,+    noImageMapping                          ,+++ -- * Methods+-- ** imageMappingCopy+    imageMappingCopy                        ,+++-- ** imageMappingFree+    imageMappingFree                        ,+++-- ** imageMappingNew+    imageMappingNew                         ,+++++ -- * Properties+-- ** Area+    imageMappingReadArea                    ,+++-- ** ImageId+    imageMappingReadImageId                 ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Poppler.Types+import GI.Poppler.Callbacks++newtype ImageMapping = ImageMapping (ForeignPtr ImageMapping)+foreign import ccall "poppler_image_mapping_get_type" c_poppler_image_mapping_get_type :: +    IO GType++instance BoxedObject ImageMapping where+    boxedType _ = c_poppler_image_mapping_get_type++noImageMapping :: Maybe ImageMapping+noImageMapping = Nothing++imageMappingReadArea :: ImageMapping -> IO Rectangle+imageMappingReadArea s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO (Ptr Rectangle)+    val' <- (newBoxed Rectangle) val+    return val'++imageMappingReadImageId :: ImageMapping -> IO Int32+imageMappingReadImageId s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 32) :: IO Int32+    return val++-- method ImageMapping::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Poppler" "ImageMapping"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_image_mapping_new" poppler_image_mapping_new :: +    IO (Ptr ImageMapping)+++imageMappingNew ::+    (MonadIO m) =>+    m ImageMapping+imageMappingNew  = liftIO $ do+    result <- poppler_image_mapping_new+    checkUnexpectedReturnNULL "poppler_image_mapping_new" result+    result' <- (wrapBoxed ImageMapping) result+    return result'++-- method ImageMapping::copy+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "ImageMapping", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "ImageMapping", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "ImageMapping"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_image_mapping_copy" poppler_image_mapping_copy :: +    Ptr ImageMapping ->                     -- _obj : TInterface "Poppler" "ImageMapping"+    IO (Ptr ImageMapping)+++imageMappingCopy ::+    (MonadIO m) =>+    ImageMapping ->                         -- _obj+    m ImageMapping+imageMappingCopy _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- poppler_image_mapping_copy _obj'+    checkUnexpectedReturnNULL "poppler_image_mapping_copy" result+    result' <- (wrapBoxed ImageMapping) result+    touchManagedPtr _obj+    return result'++-- method ImageMapping::free+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "ImageMapping", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "ImageMapping", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_image_mapping_free" poppler_image_mapping_free :: +    Ptr ImageMapping ->                     -- _obj : TInterface "Poppler" "ImageMapping"+    IO ()+++imageMappingFree ::+    (MonadIO m) =>+    ImageMapping ->                         -- _obj+    m ()+imageMappingFree _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    poppler_image_mapping_free _obj'+    touchManagedPtr _obj+    return ()++
+ GI/Poppler/Structs/ImageMapping.hs-boot view
@@ -0,0 +1,11 @@+module GI.Poppler.Structs.ImageMapping where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype ImageMapping = ImageMapping (ForeignPtr ImageMapping)+instance BoxedObject ImageMapping where
+ GI/Poppler/Structs/IndexIter.hs view
@@ -0,0 +1,247 @@++{- |+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.IndexIter+    ( ++-- * Exported types+    IndexIter(..)                           ,+    noIndexIter                             ,+++ -- * Methods+-- ** indexIterCopy+    indexIterCopy                           ,+++-- ** indexIterFree+    indexIterFree                           ,+++-- ** indexIterGetAction+    indexIterGetAction                      ,+++-- ** indexIterGetChild+    indexIterGetChild                       ,+++-- ** indexIterIsOpen+    indexIterIsOpen                         ,+++-- ** indexIterNew+    indexIterNew                            ,+++-- ** indexIterNext+    indexIterNext                           ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Poppler.Types+import GI.Poppler.Callbacks++newtype IndexIter = IndexIter (ForeignPtr IndexIter)+foreign import ccall "poppler_index_iter_get_type" c_poppler_index_iter_get_type :: +    IO GType++instance BoxedObject IndexIter where+    boxedType _ = c_poppler_index_iter_get_type++noIndexIter :: Maybe IndexIter+noIndexIter = Nothing++-- method IndexIter::new+-- method type : Constructor+-- Args : [Arg {argName = "document", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "document", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "IndexIter"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_index_iter_new" poppler_index_iter_new :: +    Ptr Document ->                         -- document : TInterface "Poppler" "Document"+    IO (Ptr IndexIter)+++indexIterNew ::+    (MonadIO m, DocumentK a) =>+    a ->                                    -- document+    m IndexIter+indexIterNew document = liftIO $ do+    let document' = unsafeManagedPtrCastPtr document+    result <- poppler_index_iter_new document'+    checkUnexpectedReturnNULL "poppler_index_iter_new" result+    result' <- (wrapBoxed IndexIter) result+    touchManagedPtr document+    return result'++-- method IndexIter::copy+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "IndexIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "IndexIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "IndexIter"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_index_iter_copy" poppler_index_iter_copy :: +    Ptr IndexIter ->                        -- _obj : TInterface "Poppler" "IndexIter"+    IO (Ptr IndexIter)+++indexIterCopy ::+    (MonadIO m) =>+    IndexIter ->                            -- _obj+    m IndexIter+indexIterCopy _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- poppler_index_iter_copy _obj'+    checkUnexpectedReturnNULL "poppler_index_iter_copy" result+    result' <- (wrapBoxed IndexIter) result+    touchManagedPtr _obj+    return result'++-- method IndexIter::free+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "IndexIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "IndexIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_index_iter_free" poppler_index_iter_free :: +    Ptr IndexIter ->                        -- _obj : TInterface "Poppler" "IndexIter"+    IO ()+++indexIterFree ::+    (MonadIO m) =>+    IndexIter ->                            -- _obj+    m ()+indexIterFree _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    poppler_index_iter_free _obj'+    touchManagedPtr _obj+    return ()++-- method IndexIter::get_action+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "IndexIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "IndexIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "Action"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_index_iter_get_action" poppler_index_iter_get_action :: +    Ptr IndexIter ->                        -- _obj : TInterface "Poppler" "IndexIter"+    IO (Ptr Action)+++indexIterGetAction ::+    (MonadIO m) =>+    IndexIter ->                            -- _obj+    m Action+indexIterGetAction _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- poppler_index_iter_get_action _obj'+    checkUnexpectedReturnNULL "poppler_index_iter_get_action" result+    result' <- (wrapBoxed Action) result+    touchManagedPtr _obj+    return result'++-- method IndexIter::get_child+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "IndexIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "IndexIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "IndexIter"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_index_iter_get_child" poppler_index_iter_get_child :: +    Ptr IndexIter ->                        -- _obj : TInterface "Poppler" "IndexIter"+    IO (Ptr IndexIter)+++indexIterGetChild ::+    (MonadIO m) =>+    IndexIter ->                            -- _obj+    m IndexIter+indexIterGetChild _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- poppler_index_iter_get_child _obj'+    checkUnexpectedReturnNULL "poppler_index_iter_get_child" result+    result' <- (wrapBoxed IndexIter) result+    touchManagedPtr _obj+    return result'++-- method IndexIter::is_open+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "IndexIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "IndexIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "poppler_index_iter_is_open" poppler_index_iter_is_open :: +    Ptr IndexIter ->                        -- _obj : TInterface "Poppler" "IndexIter"+    IO CInt+++indexIterIsOpen ::+    (MonadIO m) =>+    IndexIter ->                            -- _obj+    m Bool+indexIterIsOpen _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- poppler_index_iter_is_open _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method IndexIter::next+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "IndexIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "IndexIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "poppler_index_iter_next" poppler_index_iter_next :: +    Ptr IndexIter ->                        -- _obj : TInterface "Poppler" "IndexIter"+    IO CInt+++indexIterNext ::+    (MonadIO m) =>+    IndexIter ->                            -- _obj+    m Bool+indexIterNext _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- poppler_index_iter_next _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++
+ GI/Poppler/Structs/IndexIter.hs-boot view
@@ -0,0 +1,11 @@+module GI.Poppler.Structs.IndexIter where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype IndexIter = IndexIter (ForeignPtr IndexIter)+instance BoxedObject IndexIter where
+ GI/Poppler/Structs/LayersIter.hs view
@@ -0,0 +1,249 @@++{- |+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.LayersIter+    ( ++-- * Exported types+    LayersIter(..)                          ,+    noLayersIter                            ,+++ -- * Methods+-- ** layersIterCopy+    layersIterCopy                          ,+++-- ** layersIterFree+    layersIterFree                          ,+++-- ** layersIterGetChild+    layersIterGetChild                      ,+++-- ** layersIterGetLayer+    layersIterGetLayer                      ,+++-- ** layersIterGetTitle+    layersIterGetTitle                      ,+++-- ** layersIterNew+    layersIterNew                           ,+++-- ** layersIterNext+    layersIterNext                          ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Poppler.Types+import GI.Poppler.Callbacks++newtype LayersIter = LayersIter (ForeignPtr LayersIter)+foreign import ccall "poppler_layers_iter_get_type" c_poppler_layers_iter_get_type :: +    IO GType++instance BoxedObject LayersIter where+    boxedType _ = c_poppler_layers_iter_get_type++noLayersIter :: Maybe LayersIter+noLayersIter = Nothing++-- method LayersIter::new+-- method type : Constructor+-- Args : [Arg {argName = "document", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "document", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "LayersIter"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_layers_iter_new" poppler_layers_iter_new :: +    Ptr Document ->                         -- document : TInterface "Poppler" "Document"+    IO (Ptr LayersIter)+++layersIterNew ::+    (MonadIO m, DocumentK a) =>+    a ->                                    -- document+    m LayersIter+layersIterNew document = liftIO $ do+    let document' = unsafeManagedPtrCastPtr document+    result <- poppler_layers_iter_new document'+    checkUnexpectedReturnNULL "poppler_layers_iter_new" result+    result' <- (wrapBoxed LayersIter) result+    touchManagedPtr document+    return result'++-- method LayersIter::copy+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "LayersIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "LayersIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "LayersIter"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_layers_iter_copy" poppler_layers_iter_copy :: +    Ptr LayersIter ->                       -- _obj : TInterface "Poppler" "LayersIter"+    IO (Ptr LayersIter)+++layersIterCopy ::+    (MonadIO m) =>+    LayersIter ->                           -- _obj+    m LayersIter+layersIterCopy _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- poppler_layers_iter_copy _obj'+    checkUnexpectedReturnNULL "poppler_layers_iter_copy" result+    result' <- (wrapBoxed LayersIter) result+    touchManagedPtr _obj+    return result'++-- method LayersIter::free+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "LayersIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "LayersIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_layers_iter_free" poppler_layers_iter_free :: +    Ptr LayersIter ->                       -- _obj : TInterface "Poppler" "LayersIter"+    IO ()+++layersIterFree ::+    (MonadIO m) =>+    LayersIter ->                           -- _obj+    m ()+layersIterFree _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    poppler_layers_iter_free _obj'+    touchManagedPtr _obj+    return ()++-- method LayersIter::get_child+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "LayersIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "LayersIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "LayersIter"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_layers_iter_get_child" poppler_layers_iter_get_child :: +    Ptr LayersIter ->                       -- _obj : TInterface "Poppler" "LayersIter"+    IO (Ptr LayersIter)+++layersIterGetChild ::+    (MonadIO m) =>+    LayersIter ->                           -- _obj+    m LayersIter+layersIterGetChild _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- poppler_layers_iter_get_child _obj'+    checkUnexpectedReturnNULL "poppler_layers_iter_get_child" result+    result' <- (wrapBoxed LayersIter) result+    touchManagedPtr _obj+    return result'++-- method LayersIter::get_layer+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "LayersIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "LayersIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "Layer"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_layers_iter_get_layer" poppler_layers_iter_get_layer :: +    Ptr LayersIter ->                       -- _obj : TInterface "Poppler" "LayersIter"+    IO (Ptr Layer)+++layersIterGetLayer ::+    (MonadIO m) =>+    LayersIter ->                           -- _obj+    m Layer+layersIterGetLayer _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- poppler_layers_iter_get_layer _obj'+    checkUnexpectedReturnNULL "poppler_layers_iter_get_layer" result+    result' <- (wrapObject Layer) result+    touchManagedPtr _obj+    return result'++-- method LayersIter::get_title+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "LayersIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "LayersIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "poppler_layers_iter_get_title" poppler_layers_iter_get_title :: +    Ptr LayersIter ->                       -- _obj : TInterface "Poppler" "LayersIter"+    IO CString+++layersIterGetTitle ::+    (MonadIO m) =>+    LayersIter ->                           -- _obj+    m T.Text+layersIterGetTitle _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- poppler_layers_iter_get_title _obj'+    checkUnexpectedReturnNULL "poppler_layers_iter_get_title" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++-- method LayersIter::next+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "LayersIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "LayersIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "poppler_layers_iter_next" poppler_layers_iter_next :: +    Ptr LayersIter ->                       -- _obj : TInterface "Poppler" "LayersIter"+    IO CInt+++layersIterNext ::+    (MonadIO m) =>+    LayersIter ->                           -- _obj+    m Bool+layersIterNext _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- poppler_layers_iter_next _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++
+ GI/Poppler/Structs/LayersIter.hs-boot view
@@ -0,0 +1,11 @@+module GI.Poppler.Structs.LayersIter where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype LayersIter = LayersIter (ForeignPtr LayersIter)+instance BoxedObject LayersIter where
+ GI/Poppler/Structs/LinkMapping.hs view
@@ -0,0 +1,151 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++A #PopplerLinkMapping structure represents the location+of @action on the page+-}++module GI.Poppler.Structs.LinkMapping+    ( ++-- * Exported types+    LinkMapping(..)                         ,+    noLinkMapping                           ,+++ -- * Methods+-- ** linkMappingCopy+    linkMappingCopy                         ,+++-- ** linkMappingFree+    linkMappingFree                         ,+++-- ** linkMappingNew+    linkMappingNew                          ,+++++ -- * Properties+-- ** Action+    linkMappingReadAction                   ,+++-- ** Area+    linkMappingReadArea                     ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Poppler.Types+import GI.Poppler.Callbacks++newtype LinkMapping = LinkMapping (ForeignPtr LinkMapping)+foreign import ccall "poppler_link_mapping_get_type" c_poppler_link_mapping_get_type :: +    IO GType++instance BoxedObject LinkMapping where+    boxedType _ = c_poppler_link_mapping_get_type++noLinkMapping :: Maybe LinkMapping+noLinkMapping = Nothing++linkMappingReadArea :: LinkMapping -> IO Rectangle+linkMappingReadArea s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO (Ptr Rectangle)+    val' <- (newBoxed Rectangle) val+    return val'++linkMappingReadAction :: LinkMapping -> IO Action+linkMappingReadAction s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 32) :: IO (Ptr Action)+    val' <- (newBoxed Action) val+    return val'++-- method LinkMapping::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Poppler" "LinkMapping"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_link_mapping_new" poppler_link_mapping_new :: +    IO (Ptr LinkMapping)+++linkMappingNew ::+    (MonadIO m) =>+    m LinkMapping+linkMappingNew  = liftIO $ do+    result <- poppler_link_mapping_new+    checkUnexpectedReturnNULL "poppler_link_mapping_new" result+    result' <- (wrapBoxed LinkMapping) result+    return result'++-- method LinkMapping::copy+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "LinkMapping", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "LinkMapping", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "LinkMapping"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_link_mapping_copy" poppler_link_mapping_copy :: +    Ptr LinkMapping ->                      -- _obj : TInterface "Poppler" "LinkMapping"+    IO (Ptr LinkMapping)+++linkMappingCopy ::+    (MonadIO m) =>+    LinkMapping ->                          -- _obj+    m LinkMapping+linkMappingCopy _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- poppler_link_mapping_copy _obj'+    checkUnexpectedReturnNULL "poppler_link_mapping_copy" result+    result' <- (wrapBoxed LinkMapping) result+    touchManagedPtr _obj+    return result'++-- method LinkMapping::free+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "LinkMapping", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "LinkMapping", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_link_mapping_free" poppler_link_mapping_free :: +    Ptr LinkMapping ->                      -- _obj : TInterface "Poppler" "LinkMapping"+    IO ()+++linkMappingFree ::+    (MonadIO m) =>+    LinkMapping ->                          -- _obj+    m ()+linkMappingFree _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    poppler_link_mapping_free _obj'+    touchManagedPtr _obj+    return ()++
+ GI/Poppler/Structs/LinkMapping.hs-boot view
@@ -0,0 +1,11 @@+module GI.Poppler.Structs.LinkMapping where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype LinkMapping = LinkMapping (ForeignPtr LinkMapping)+instance BoxedObject LinkMapping where
+ GI/Poppler/Structs/PageTransition.hs view
@@ -0,0 +1,199 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++A #PopplerPageTransition structures describes a visual transition+to use when moving between pages during a presentation+-}++module GI.Poppler.Structs.PageTransition+    ( ++-- * Exported types+    PageTransition(..)                      ,+    noPageTransition                        ,+++ -- * Methods+-- ** pageTransitionCopy+    pageTransitionCopy                      ,+++-- ** pageTransitionFree+    pageTransitionFree                      ,+++-- ** pageTransitionNew+    pageTransitionNew                       ,+++++ -- * Properties+-- ** Alignment+    pageTransitionReadAlignment             ,+++-- ** Angle+    pageTransitionReadAngle                 ,+++-- ** Direction+    pageTransitionReadDirection             ,+++-- ** Duration+    pageTransitionReadDuration              ,+++-- ** Rectangular+    pageTransitionReadRectangular           ,+++-- ** Scale+    pageTransitionReadScale                 ,+++-- ** Type+    pageTransitionReadType                  ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Poppler.Types+import GI.Poppler.Callbacks++newtype PageTransition = PageTransition (ForeignPtr PageTransition)+foreign import ccall "poppler_page_transition_get_type" c_poppler_page_transition_get_type :: +    IO GType++instance BoxedObject PageTransition where+    boxedType _ = c_poppler_page_transition_get_type++noPageTransition :: Maybe PageTransition+noPageTransition = Nothing++pageTransitionReadType :: PageTransition -> IO PageTransitionType+pageTransitionReadType s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO CUInt+    let val' = (toEnum . fromIntegral) val+    return val'++pageTransitionReadAlignment :: PageTransition -> IO PageTransitionAlignment+pageTransitionReadAlignment s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 4) :: IO CUInt+    let val' = (toEnum . fromIntegral) val+    return val'++pageTransitionReadDirection :: PageTransition -> IO PageTransitionDirection+pageTransitionReadDirection s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 8) :: IO CUInt+    let val' = (toEnum . fromIntegral) val+    return val'++pageTransitionReadDuration :: PageTransition -> IO Int32+pageTransitionReadDuration s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 12) :: IO Int32+    return val++pageTransitionReadAngle :: PageTransition -> IO Int32+pageTransitionReadAngle s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 16) :: IO Int32+    return val++pageTransitionReadScale :: PageTransition -> IO Double+pageTransitionReadScale s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 24) :: IO CDouble+    let val' = realToFrac val+    return val'++pageTransitionReadRectangular :: PageTransition -> IO Bool+pageTransitionReadRectangular s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 32) :: IO CInt+    let val' = (/= 0) val+    return val'++-- method PageTransition::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Poppler" "PageTransition"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_page_transition_new" poppler_page_transition_new :: +    IO (Ptr PageTransition)+++pageTransitionNew ::+    (MonadIO m) =>+    m PageTransition+pageTransitionNew  = liftIO $ do+    result <- poppler_page_transition_new+    checkUnexpectedReturnNULL "poppler_page_transition_new" result+    result' <- (wrapBoxed PageTransition) result+    return result'++-- method PageTransition::copy+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "PageTransition", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "PageTransition", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "PageTransition"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_page_transition_copy" poppler_page_transition_copy :: +    Ptr PageTransition ->                   -- _obj : TInterface "Poppler" "PageTransition"+    IO (Ptr PageTransition)+++pageTransitionCopy ::+    (MonadIO m) =>+    PageTransition ->                       -- _obj+    m PageTransition+pageTransitionCopy _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- poppler_page_transition_copy _obj'+    checkUnexpectedReturnNULL "poppler_page_transition_copy" result+    result' <- (wrapBoxed PageTransition) result+    touchManagedPtr _obj+    return result'++-- method PageTransition::free+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "PageTransition", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "PageTransition", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_page_transition_free" poppler_page_transition_free :: +    Ptr PageTransition ->                   -- _obj : TInterface "Poppler" "PageTransition"+    IO ()+++pageTransitionFree ::+    (MonadIO m) =>+    PageTransition ->                       -- _obj+    m ()+pageTransitionFree _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    poppler_page_transition_free _obj'+    touchManagedPtr _obj+    return ()++
+ GI/Poppler/Structs/PageTransition.hs-boot view
@@ -0,0 +1,11 @@+module GI.Poppler.Structs.PageTransition where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype PageTransition = PageTransition (ForeignPtr PageTransition)+instance BoxedObject PageTransition where
+ GI/Poppler/Structs/Point.hs view
@@ -0,0 +1,150 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++A #PopplerPoint is used to describe a location point on a page+-}++module GI.Poppler.Structs.Point+    ( ++-- * Exported types+    Point(..)                               ,+    noPoint                                 ,+++ -- * Methods+-- ** pointCopy+    pointCopy                               ,+++-- ** pointFree+    pointFree                               ,+++-- ** pointNew+    pointNew                                ,+++++ -- * Properties+-- ** X+    pointReadX                              ,+++-- ** Y+    pointReadY                              ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Poppler.Types+import GI.Poppler.Callbacks++newtype Point = Point (ForeignPtr Point)+foreign import ccall "poppler_point_get_type" c_poppler_point_get_type :: +    IO GType++instance BoxedObject Point where+    boxedType _ = c_poppler_point_get_type++noPoint :: Maybe Point+noPoint = Nothing++pointReadX :: Point -> IO Double+pointReadX s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO CDouble+    let val' = realToFrac val+    return val'++pointReadY :: Point -> IO Double+pointReadY s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 8) :: IO CDouble+    let val' = realToFrac val+    return val'++-- method Point::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Poppler" "Point"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_point_new" poppler_point_new :: +    IO (Ptr Point)+++pointNew ::+    (MonadIO m) =>+    m Point+pointNew  = liftIO $ do+    result <- poppler_point_new+    checkUnexpectedReturnNULL "poppler_point_new" result+    result' <- (wrapBoxed Point) result+    return result'++-- method Point::copy+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Point", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Point", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "Point"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_point_copy" poppler_point_copy :: +    Ptr Point ->                            -- _obj : TInterface "Poppler" "Point"+    IO (Ptr Point)+++pointCopy ::+    (MonadIO m) =>+    Point ->                                -- _obj+    m Point+pointCopy _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- poppler_point_copy _obj'+    checkUnexpectedReturnNULL "poppler_point_copy" result+    result' <- (wrapBoxed Point) result+    touchManagedPtr _obj+    return result'++-- method Point::free+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Point", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Point", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_point_free" poppler_point_free :: +    Ptr Point ->                            -- _obj : TInterface "Poppler" "Point"+    IO ()+++pointFree ::+    (MonadIO m) =>+    Point ->                                -- _obj+    m ()+pointFree _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    poppler_point_free _obj'+    touchManagedPtr _obj+    return ()++
+ GI/Poppler/Structs/Point.hs-boot view
@@ -0,0 +1,11 @@+module GI.Poppler.Structs.Point where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype Point = Point (ForeignPtr Point)+instance BoxedObject Point where
+ GI/Poppler/Structs/Quadrilateral.hs view
@@ -0,0 +1,173 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++A #PopplerQuadrilateral is used to describe rectangle-like polygon+ with arbitrary inclination on a page.++ Since: 0.26+-}++module GI.Poppler.Structs.Quadrilateral+    ( ++-- * Exported types+    Quadrilateral(..)                       ,+    noQuadrilateral                         ,+++ -- * Methods+-- ** quadrilateralCopy+    quadrilateralCopy                       ,+++-- ** quadrilateralFree+    quadrilateralFree                       ,+++-- ** quadrilateralNew+    quadrilateralNew                        ,+++++ -- * Properties+-- ** P1+    quadrilateralReadP1                     ,+++-- ** P2+    quadrilateralReadP2                     ,+++-- ** P3+    quadrilateralReadP3                     ,+++-- ** P4+    quadrilateralReadP4                     ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Poppler.Types+import GI.Poppler.Callbacks++newtype Quadrilateral = Quadrilateral (ForeignPtr Quadrilateral)+foreign import ccall "poppler_quadrilateral_get_type" c_poppler_quadrilateral_get_type :: +    IO GType++instance BoxedObject Quadrilateral where+    boxedType _ = c_poppler_quadrilateral_get_type++noQuadrilateral :: Maybe Quadrilateral+noQuadrilateral = Nothing++quadrilateralReadP1 :: Quadrilateral -> IO Point+quadrilateralReadP1 s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO (Ptr Point)+    val' <- (newBoxed Point) val+    return val'++quadrilateralReadP2 :: Quadrilateral -> IO Point+quadrilateralReadP2 s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 16) :: IO (Ptr Point)+    val' <- (newBoxed Point) val+    return val'++quadrilateralReadP3 :: Quadrilateral -> IO Point+quadrilateralReadP3 s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 32) :: IO (Ptr Point)+    val' <- (newBoxed Point) val+    return val'++quadrilateralReadP4 :: Quadrilateral -> IO Point+quadrilateralReadP4 s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 48) :: IO (Ptr Point)+    val' <- (newBoxed Point) val+    return val'++-- method Quadrilateral::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Poppler" "Quadrilateral"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_quadrilateral_new" poppler_quadrilateral_new :: +    IO (Ptr Quadrilateral)+++quadrilateralNew ::+    (MonadIO m) =>+    m Quadrilateral+quadrilateralNew  = liftIO $ do+    result <- poppler_quadrilateral_new+    checkUnexpectedReturnNULL "poppler_quadrilateral_new" result+    result' <- (wrapBoxed Quadrilateral) result+    return result'++-- method Quadrilateral::copy+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Quadrilateral", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Quadrilateral", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "Quadrilateral"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_quadrilateral_copy" poppler_quadrilateral_copy :: +    Ptr Quadrilateral ->                    -- _obj : TInterface "Poppler" "Quadrilateral"+    IO (Ptr Quadrilateral)+++quadrilateralCopy ::+    (MonadIO m) =>+    Quadrilateral ->                        -- _obj+    m Quadrilateral+quadrilateralCopy _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- poppler_quadrilateral_copy _obj'+    checkUnexpectedReturnNULL "poppler_quadrilateral_copy" result+    result' <- (wrapBoxed Quadrilateral) result+    touchManagedPtr _obj+    return result'++-- method Quadrilateral::free+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Quadrilateral", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Quadrilateral", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_quadrilateral_free" poppler_quadrilateral_free :: +    Ptr Quadrilateral ->                    -- _obj : TInterface "Poppler" "Quadrilateral"+    IO ()+++quadrilateralFree ::+    (MonadIO m) =>+    Quadrilateral ->                        -- _obj+    m ()+quadrilateralFree _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    poppler_quadrilateral_free _obj'+    touchManagedPtr _obj+    return ()++
+ GI/Poppler/Structs/Quadrilateral.hs-boot view
@@ -0,0 +1,11 @@+module GI.Poppler.Structs.Quadrilateral where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype Quadrilateral = Quadrilateral (ForeignPtr Quadrilateral)+instance BoxedObject Quadrilateral where
+ GI/Poppler/Structs/Rectangle.hs view
@@ -0,0 +1,171 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++A #PopplerRectangle is used to describe+locations on a page and bounding boxes+-}++module GI.Poppler.Structs.Rectangle+    ( ++-- * Exported types+    Rectangle(..)                           ,+    noRectangle                             ,+++ -- * Methods+-- ** rectangleCopy+    rectangleCopy                           ,+++-- ** rectangleFree+    rectangleFree                           ,+++-- ** rectangleNew+    rectangleNew                            ,+++++ -- * Properties+-- ** X1+    rectangleReadX1                         ,+++-- ** X2+    rectangleReadX2                         ,+++-- ** Y1+    rectangleReadY1                         ,+++-- ** Y2+    rectangleReadY2                         ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Poppler.Types+import GI.Poppler.Callbacks++newtype Rectangle = Rectangle (ForeignPtr Rectangle)+foreign import ccall "poppler_rectangle_get_type" c_poppler_rectangle_get_type :: +    IO GType++instance BoxedObject Rectangle where+    boxedType _ = c_poppler_rectangle_get_type++noRectangle :: Maybe Rectangle+noRectangle = Nothing++rectangleReadX1 :: Rectangle -> IO Double+rectangleReadX1 s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO CDouble+    let val' = realToFrac val+    return val'++rectangleReadY1 :: Rectangle -> IO Double+rectangleReadY1 s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 8) :: IO CDouble+    let val' = realToFrac val+    return val'++rectangleReadX2 :: Rectangle -> IO Double+rectangleReadX2 s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 16) :: IO CDouble+    let val' = realToFrac val+    return val'++rectangleReadY2 :: Rectangle -> IO Double+rectangleReadY2 s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 24) :: IO CDouble+    let val' = realToFrac val+    return val'++-- method Rectangle::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Poppler" "Rectangle"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_rectangle_new" poppler_rectangle_new :: +    IO (Ptr Rectangle)+++rectangleNew ::+    (MonadIO m) =>+    m Rectangle+rectangleNew  = liftIO $ do+    result <- poppler_rectangle_new+    checkUnexpectedReturnNULL "poppler_rectangle_new" result+    result' <- (wrapBoxed Rectangle) result+    return result'++-- method Rectangle::copy+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "Rectangle"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_rectangle_copy" poppler_rectangle_copy :: +    Ptr Rectangle ->                        -- _obj : TInterface "Poppler" "Rectangle"+    IO (Ptr Rectangle)+++rectangleCopy ::+    (MonadIO m) =>+    Rectangle ->                            -- _obj+    m Rectangle+rectangleCopy _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- poppler_rectangle_copy _obj'+    checkUnexpectedReturnNULL "poppler_rectangle_copy" result+    result' <- (wrapBoxed Rectangle) result+    touchManagedPtr _obj+    return result'++-- method Rectangle::free+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Rectangle", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_rectangle_free" poppler_rectangle_free :: +    Ptr Rectangle ->                        -- _obj : TInterface "Poppler" "Rectangle"+    IO ()+++rectangleFree ::+    (MonadIO m) =>+    Rectangle ->                            -- _obj+    m ()+rectangleFree _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    poppler_rectangle_free _obj'+    touchManagedPtr _obj+    return ()++
+ GI/Poppler/Structs/Rectangle.hs-boot view
@@ -0,0 +1,11 @@+module GI.Poppler.Structs.Rectangle where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype Rectangle = Rectangle (ForeignPtr Rectangle)+instance BoxedObject Rectangle where
+ GI/Poppler/Structs/StructureElementIter.hs view
@@ -0,0 +1,218 @@++{- |+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.StructureElementIter+    ( ++-- * Exported types+    StructureElementIter(..)                ,+    noStructureElementIter                  ,+++ -- * Methods+-- ** structureElementIterCopy+    structureElementIterCopy                ,+++-- ** structureElementIterFree+    structureElementIterFree                ,+++-- ** structureElementIterGetChild+    structureElementIterGetChild            ,+++-- ** structureElementIterGetElement+    structureElementIterGetElement          ,+++-- ** structureElementIterNew+    structureElementIterNew                 ,+++-- ** structureElementIterNext+    structureElementIterNext                ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Poppler.Types+import GI.Poppler.Callbacks++newtype StructureElementIter = StructureElementIter (ForeignPtr StructureElementIter)+foreign import ccall "poppler_structure_element_iter_get_type" c_poppler_structure_element_iter_get_type :: +    IO GType++instance BoxedObject StructureElementIter where+    boxedType _ = c_poppler_structure_element_iter_get_type++noStructureElementIter :: Maybe StructureElementIter+noStructureElementIter = Nothing++-- method StructureElementIter::new+-- method type : Constructor+-- Args : [Arg {argName = "poppler_document", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "poppler_document", argType = TInterface "Poppler" "Document", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "StructureElementIter"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_structure_element_iter_new" poppler_structure_element_iter_new :: +    Ptr Document ->                         -- poppler_document : TInterface "Poppler" "Document"+    IO (Ptr StructureElementIter)+++structureElementIterNew ::+    (MonadIO m, DocumentK a) =>+    a ->                                    -- poppler_document+    m StructureElementIter+structureElementIterNew poppler_document = liftIO $ do+    let poppler_document' = unsafeManagedPtrCastPtr poppler_document+    result <- poppler_structure_element_iter_new poppler_document'+    checkUnexpectedReturnNULL "poppler_structure_element_iter_new" result+    result' <- (wrapBoxed StructureElementIter) result+    touchManagedPtr poppler_document+    return result'++-- method StructureElementIter::copy+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElementIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElementIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "StructureElementIter"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_structure_element_iter_copy" poppler_structure_element_iter_copy :: +    Ptr StructureElementIter ->             -- _obj : TInterface "Poppler" "StructureElementIter"+    IO (Ptr StructureElementIter)+++structureElementIterCopy ::+    (MonadIO m) =>+    StructureElementIter ->                 -- _obj+    m StructureElementIter+structureElementIterCopy _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- poppler_structure_element_iter_copy _obj'+    checkUnexpectedReturnNULL "poppler_structure_element_iter_copy" result+    result' <- (wrapBoxed StructureElementIter) result+    touchManagedPtr _obj+    return result'++-- method StructureElementIter::free+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElementIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElementIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_structure_element_iter_free" poppler_structure_element_iter_free :: +    Ptr StructureElementIter ->             -- _obj : TInterface "Poppler" "StructureElementIter"+    IO ()+++structureElementIterFree ::+    (MonadIO m) =>+    StructureElementIter ->                 -- _obj+    m ()+structureElementIterFree _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    poppler_structure_element_iter_free _obj'+    touchManagedPtr _obj+    return ()++-- method StructureElementIter::get_child+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElementIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElementIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "StructureElementIter"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_structure_element_iter_get_child" poppler_structure_element_iter_get_child :: +    Ptr StructureElementIter ->             -- _obj : TInterface "Poppler" "StructureElementIter"+    IO (Ptr StructureElementIter)+++structureElementIterGetChild ::+    (MonadIO m) =>+    StructureElementIter ->                 -- _obj+    m StructureElementIter+structureElementIterGetChild _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- poppler_structure_element_iter_get_child _obj'+    checkUnexpectedReturnNULL "poppler_structure_element_iter_get_child" result+    result' <- (wrapBoxed StructureElementIter) result+    touchManagedPtr _obj+    return result'++-- method StructureElementIter::get_element+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElementIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElementIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "StructureElement"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_structure_element_iter_get_element" poppler_structure_element_iter_get_element :: +    Ptr StructureElementIter ->             -- _obj : TInterface "Poppler" "StructureElementIter"+    IO (Ptr StructureElement)+++structureElementIterGetElement ::+    (MonadIO m) =>+    StructureElementIter ->                 -- _obj+    m StructureElement+structureElementIterGetElement _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- poppler_structure_element_iter_get_element _obj'+    checkUnexpectedReturnNULL "poppler_structure_element_iter_get_element" result+    result' <- (wrapObject StructureElement) result+    touchManagedPtr _obj+    return result'++-- method StructureElementIter::next+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElementIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "StructureElementIter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "poppler_structure_element_iter_next" poppler_structure_element_iter_next :: +    Ptr StructureElementIter ->             -- _obj : TInterface "Poppler" "StructureElementIter"+    IO CInt+++structureElementIterNext ::+    (MonadIO m) =>+    StructureElementIter ->                 -- _obj+    m Bool+structureElementIterNext _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- poppler_structure_element_iter_next _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++
+ GI/Poppler/Structs/StructureElementIter.hs-boot view
@@ -0,0 +1,11 @@+module GI.Poppler.Structs.StructureElementIter where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype StructureElementIter = StructureElementIter (ForeignPtr StructureElementIter)+instance BoxedObject StructureElementIter where
+ GI/Poppler/Structs/TextAttributes.hs view
@@ -0,0 +1,188 @@++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++A #PopplerTextAttributes is used to describe text attributes of a range of text+-}++module GI.Poppler.Structs.TextAttributes+    ( ++-- * Exported types+    TextAttributes(..)                      ,+    noTextAttributes                        ,+++ -- * Methods+-- ** textAttributesCopy+    textAttributesCopy                      ,+++-- ** textAttributesFree+    textAttributesFree                      ,+++-- ** textAttributesNew+    textAttributesNew                       ,+++++ -- * Properties+-- ** Color+    textAttributesReadColor                 ,+++-- ** EndIndex+    textAttributesReadEndIndex              ,+++-- ** FontName+    textAttributesReadFontName              ,+++-- ** FontSize+    textAttributesReadFontSize              ,+++-- ** IsUnderlined+    textAttributesReadIsUnderlined          ,+++-- ** StartIndex+    textAttributesReadStartIndex            ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Poppler.Types+import GI.Poppler.Callbacks++newtype TextAttributes = TextAttributes (ForeignPtr TextAttributes)+foreign import ccall "poppler_text_attributes_get_type" c_poppler_text_attributes_get_type :: +    IO GType++instance BoxedObject TextAttributes where+    boxedType _ = c_poppler_text_attributes_get_type++noTextAttributes :: Maybe TextAttributes+noTextAttributes = Nothing++textAttributesReadFontName :: TextAttributes -> IO T.Text+textAttributesReadFontName s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO CString+    val' <- cstringToText val+    return val'++textAttributesReadFontSize :: TextAttributes -> IO Double+textAttributesReadFontSize s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 8) :: IO CDouble+    let val' = realToFrac val+    return val'++textAttributesReadIsUnderlined :: TextAttributes -> IO Bool+textAttributesReadIsUnderlined s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 16) :: IO CInt+    let val' = (/= 0) val+    return val'++textAttributesReadColor :: TextAttributes -> IO Color+textAttributesReadColor s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 20) :: IO (Ptr Color)+    val' <- (newBoxed Color) val+    return val'++textAttributesReadStartIndex :: TextAttributes -> IO Int32+textAttributesReadStartIndex s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 28) :: IO Int32+    return val++textAttributesReadEndIndex :: TextAttributes -> IO Int32+textAttributesReadEndIndex s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 32) :: IO Int32+    return val++-- method TextAttributes::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- hInArgs : []+-- returnType : TInterface "Poppler" "TextAttributes"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_text_attributes_new" poppler_text_attributes_new :: +    IO (Ptr TextAttributes)+++textAttributesNew ::+    (MonadIO m) =>+    m TextAttributes+textAttributesNew  = liftIO $ do+    result <- poppler_text_attributes_new+    checkUnexpectedReturnNULL "poppler_text_attributes_new" result+    result' <- (wrapBoxed TextAttributes) result+    return result'++-- method TextAttributes::copy+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "TextAttributes", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "TextAttributes", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "TextAttributes"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_text_attributes_copy" poppler_text_attributes_copy :: +    Ptr TextAttributes ->                   -- _obj : TInterface "Poppler" "TextAttributes"+    IO (Ptr TextAttributes)+++textAttributesCopy ::+    (MonadIO m) =>+    TextAttributes ->                       -- _obj+    m TextAttributes+textAttributesCopy _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- poppler_text_attributes_copy _obj'+    checkUnexpectedReturnNULL "poppler_text_attributes_copy" result+    result' <- (wrapBoxed TextAttributes) result+    touchManagedPtr _obj+    return result'++-- method TextAttributes::free+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "TextAttributes", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "TextAttributes", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_text_attributes_free" poppler_text_attributes_free :: +    Ptr TextAttributes ->                   -- _obj : TInterface "Poppler" "TextAttributes"+    IO ()+++textAttributesFree ::+    (MonadIO m) =>+    TextAttributes ->                       -- _obj+    m ()+textAttributesFree _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    poppler_text_attributes_free _obj'+    touchManagedPtr _obj+    return ()++
+ GI/Poppler/Structs/TextAttributes.hs-boot view
@@ -0,0 +1,11 @@+module GI.Poppler.Structs.TextAttributes where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype TextAttributes = TextAttributes (ForeignPtr TextAttributes)+instance BoxedObject TextAttributes where
+ GI/Poppler/Structs/TextSpan.hs view
@@ -0,0 +1,277 @@++{- |+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.TextSpan+    ( ++-- * Exported types+    TextSpan(..)                            ,+    noTextSpan                              ,+++ -- * Methods+-- ** textSpanCopy+    textSpanCopy                            ,+++-- ** textSpanFree+    textSpanFree                            ,+++-- ** textSpanGetColor+    textSpanGetColor                        ,+++-- ** textSpanGetFontName+    textSpanGetFontName                     ,+++-- ** textSpanGetText+    textSpanGetText                         ,+++-- ** textSpanIsBoldFont+    textSpanIsBoldFont                      ,+++-- ** textSpanIsFixedWidthFont+    textSpanIsFixedWidthFont                ,+++-- ** textSpanIsSerifFont+    textSpanIsSerifFont                     ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Poppler.Types+import GI.Poppler.Callbacks++newtype TextSpan = TextSpan (ForeignPtr TextSpan)+foreign import ccall "poppler_text_span_get_type" c_poppler_text_span_get_type :: +    IO GType++instance BoxedObject TextSpan where+    boxedType _ = c_poppler_text_span_get_type++noTextSpan :: Maybe TextSpan+noTextSpan = Nothing++-- method TextSpan::copy+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "TextSpan", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "TextSpan", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "TextSpan"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_text_span_copy" poppler_text_span_copy :: +    Ptr TextSpan ->                         -- _obj : TInterface "Poppler" "TextSpan"+    IO (Ptr TextSpan)+++textSpanCopy ::+    (MonadIO m) =>+    TextSpan ->                             -- _obj+    m TextSpan+textSpanCopy _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- poppler_text_span_copy _obj'+    checkUnexpectedReturnNULL "poppler_text_span_copy" result+    result' <- (wrapBoxed TextSpan) result+    touchManagedPtr _obj+    return result'++-- method TextSpan::free+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "TextSpan", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "TextSpan", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_text_span_free" poppler_text_span_free :: +    Ptr TextSpan ->                         -- _obj : TInterface "Poppler" "TextSpan"+    IO ()+++textSpanFree ::+    (MonadIO m) =>+    TextSpan ->                             -- _obj+    m ()+textSpanFree _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    poppler_text_span_free _obj'+    touchManagedPtr _obj+    return ()++-- method TextSpan::get_color+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "TextSpan", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing},Arg {argName = "color", argType = TInterface "Poppler" "Color", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "TextSpan", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_text_span_get_color" poppler_text_span_get_color :: +    Ptr TextSpan ->                         -- _obj : TInterface "Poppler" "TextSpan"+    Ptr Color ->                            -- color : TInterface "Poppler" "Color"+    IO ()+++textSpanGetColor ::+    (MonadIO m) =>+    TextSpan ->                             -- _obj+    m (Color)+textSpanGetColor _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    color <- callocBoxedBytes 6 :: IO (Ptr Color)+    poppler_text_span_get_color _obj' color+    color' <- (wrapBoxed Color) color+    touchManagedPtr _obj+    return color'++-- method TextSpan::get_font_name+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "TextSpan", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "TextSpan", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "poppler_text_span_get_font_name" poppler_text_span_get_font_name :: +    Ptr TextSpan ->                         -- _obj : TInterface "Poppler" "TextSpan"+    IO CString+++textSpanGetFontName ::+    (MonadIO m) =>+    TextSpan ->                             -- _obj+    m T.Text+textSpanGetFontName _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- poppler_text_span_get_font_name _obj'+    checkUnexpectedReturnNULL "poppler_text_span_get_font_name" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method TextSpan::get_text+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "TextSpan", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "TextSpan", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "poppler_text_span_get_text" poppler_text_span_get_text :: +    Ptr TextSpan ->                         -- _obj : TInterface "Poppler" "TextSpan"+    IO CString+++textSpanGetText ::+    (MonadIO m) =>+    TextSpan ->                             -- _obj+    m T.Text+textSpanGetText _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- poppler_text_span_get_text _obj'+    checkUnexpectedReturnNULL "poppler_text_span_get_text" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++-- method TextSpan::is_bold_font+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "TextSpan", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "TextSpan", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "poppler_text_span_is_bold_font" poppler_text_span_is_bold_font :: +    Ptr TextSpan ->                         -- _obj : TInterface "Poppler" "TextSpan"+    IO CInt+++textSpanIsBoldFont ::+    (MonadIO m) =>+    TextSpan ->                             -- _obj+    m Bool+textSpanIsBoldFont _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- poppler_text_span_is_bold_font _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method TextSpan::is_fixed_width_font+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "TextSpan", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "TextSpan", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "poppler_text_span_is_fixed_width_font" poppler_text_span_is_fixed_width_font :: +    Ptr TextSpan ->                         -- _obj : TInterface "Poppler" "TextSpan"+    IO CInt+++textSpanIsFixedWidthFont ::+    (MonadIO m) =>+    TextSpan ->                             -- _obj+    m Bool+textSpanIsFixedWidthFont _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- poppler_text_span_is_fixed_width_font _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++-- method TextSpan::is_serif_font+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "TextSpan", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "TextSpan", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "poppler_text_span_is_serif_font" poppler_text_span_is_serif_font :: +    Ptr TextSpan ->                         -- _obj : TInterface "Poppler" "TextSpan"+    IO CInt+++textSpanIsSerifFont ::+    (MonadIO m) =>+    TextSpan ->                             -- _obj+    m Bool+textSpanIsSerifFont _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- poppler_text_span_is_serif_font _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++
+ GI/Poppler/Structs/TextSpan.hs-boot view
@@ -0,0 +1,11 @@+module GI.Poppler.Structs.TextSpan where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype TextSpan = TextSpan (ForeignPtr TextSpan)+instance BoxedObject TextSpan where
+ GI/Poppler/Types.hs view
@@ -0,0 +1,112 @@+module GI.Poppler.Types+    (     module GI.Poppler.Objects.Annot         ,+    module GI.Poppler.Objects.AnnotCircle   ,+    module GI.Poppler.Objects.AnnotFileAttachment,+    module GI.Poppler.Objects.AnnotFreeText ,+    module GI.Poppler.Objects.AnnotLine     ,+    module GI.Poppler.Objects.AnnotMarkup   ,+    module GI.Poppler.Objects.AnnotMovie    ,+    module GI.Poppler.Objects.AnnotScreen   ,+    module GI.Poppler.Objects.AnnotSquare   ,+    module GI.Poppler.Objects.AnnotText     ,+    module GI.Poppler.Objects.AnnotTextMarkup,+    module GI.Poppler.Objects.Attachment    ,+    module GI.Poppler.Objects.Document      ,+    module GI.Poppler.Objects.FontInfo      ,+    module GI.Poppler.Objects.FormField     ,+    module GI.Poppler.Objects.Layer         ,+    module GI.Poppler.Objects.Media         ,+    module GI.Poppler.Objects.Movie         ,+    module GI.Poppler.Objects.PSFile        ,+    module GI.Poppler.Objects.Page          ,+    module GI.Poppler.Objects.StructureElement,+    module GI.Poppler.Structs.ActionAny     ,+    module GI.Poppler.Structs.ActionGotoDest,+    module GI.Poppler.Structs.ActionGotoRemote,+    module GI.Poppler.Structs.ActionJavascript,+    module GI.Poppler.Structs.ActionLaunch  ,+    module GI.Poppler.Structs.ActionLayer   ,+    module GI.Poppler.Structs.ActionMovie   ,+    module GI.Poppler.Structs.ActionNamed   ,+    module GI.Poppler.Structs.ActionOCGState,+    module GI.Poppler.Structs.ActionRendition,+    module GI.Poppler.Structs.ActionUri     ,+    module GI.Poppler.Structs.AnnotCalloutLine,+    module GI.Poppler.Structs.AnnotMapping  ,+    module GI.Poppler.Structs.Color         ,+    module GI.Poppler.Structs.Dest          ,+    module GI.Poppler.Structs.FontsIter     ,+    module GI.Poppler.Structs.FormFieldMapping,+    module GI.Poppler.Structs.ImageMapping  ,+    module GI.Poppler.Structs.IndexIter     ,+    module GI.Poppler.Structs.LayersIter    ,+    module GI.Poppler.Structs.LinkMapping   ,+    module GI.Poppler.Structs.PageTransition,+    module GI.Poppler.Structs.Point         ,+    module GI.Poppler.Structs.Quadrilateral ,+    module GI.Poppler.Structs.Rectangle     ,+    module GI.Poppler.Structs.StructureElementIter,+    module GI.Poppler.Structs.TextAttributes,+    module GI.Poppler.Structs.TextSpan      ,+    module GI.Poppler.Unions.Action         ,+    module GI.Poppler.Enums                 ,+    module GI.Poppler.Flags                 ,+++    ) where+++import {-# SOURCE #-} GI.Poppler.Objects.Annot+import {-# SOURCE #-} GI.Poppler.Objects.AnnotCircle+import {-# SOURCE #-} GI.Poppler.Objects.AnnotFileAttachment+import {-# SOURCE #-} GI.Poppler.Objects.AnnotFreeText+import {-# SOURCE #-} GI.Poppler.Objects.AnnotLine+import {-# SOURCE #-} GI.Poppler.Objects.AnnotMarkup+import {-# SOURCE #-} GI.Poppler.Objects.AnnotMovie+import {-# SOURCE #-} GI.Poppler.Objects.AnnotScreen+import {-# SOURCE #-} GI.Poppler.Objects.AnnotSquare+import {-# SOURCE #-} GI.Poppler.Objects.AnnotText+import {-# SOURCE #-} GI.Poppler.Objects.AnnotTextMarkup+import {-# SOURCE #-} GI.Poppler.Objects.Attachment+import {-# SOURCE #-} GI.Poppler.Objects.Document+import {-# SOURCE #-} GI.Poppler.Objects.FontInfo+import {-# SOURCE #-} GI.Poppler.Objects.FormField+import {-# SOURCE #-} GI.Poppler.Objects.Layer+import {-# SOURCE #-} GI.Poppler.Objects.Media+import {-# SOURCE #-} GI.Poppler.Objects.Movie+import {-# SOURCE #-} GI.Poppler.Objects.PSFile+import {-# SOURCE #-} GI.Poppler.Objects.Page+import {-# SOURCE #-} GI.Poppler.Objects.StructureElement+import {-# SOURCE #-} GI.Poppler.Structs.ActionAny+import {-# SOURCE #-} GI.Poppler.Structs.ActionGotoDest+import {-# SOURCE #-} GI.Poppler.Structs.ActionGotoRemote+import {-# SOURCE #-} GI.Poppler.Structs.ActionJavascript+import {-# SOURCE #-} GI.Poppler.Structs.ActionLaunch+import {-# SOURCE #-} GI.Poppler.Structs.ActionLayer+import {-# SOURCE #-} GI.Poppler.Structs.ActionMovie+import {-# SOURCE #-} GI.Poppler.Structs.ActionNamed+import {-# SOURCE #-} GI.Poppler.Structs.ActionOCGState+import {-# SOURCE #-} GI.Poppler.Structs.ActionRendition+import {-# SOURCE #-} GI.Poppler.Structs.ActionUri+import {-# SOURCE #-} GI.Poppler.Structs.AnnotCalloutLine+import {-# SOURCE #-} GI.Poppler.Structs.AnnotMapping+import {-# SOURCE #-} GI.Poppler.Structs.Color+import {-# SOURCE #-} GI.Poppler.Structs.Dest+import {-# SOURCE #-} GI.Poppler.Structs.FontsIter+import {-# SOURCE #-} GI.Poppler.Structs.FormFieldMapping+import {-# SOURCE #-} GI.Poppler.Structs.ImageMapping+import {-# SOURCE #-} GI.Poppler.Structs.IndexIter+import {-# SOURCE #-} GI.Poppler.Structs.LayersIter+import {-# SOURCE #-} GI.Poppler.Structs.LinkMapping+import {-# SOURCE #-} GI.Poppler.Structs.PageTransition+import {-# SOURCE #-} GI.Poppler.Structs.Point+import {-# SOURCE #-} GI.Poppler.Structs.Quadrilateral+import {-# SOURCE #-} GI.Poppler.Structs.Rectangle+import {-# SOURCE #-} GI.Poppler.Structs.StructureElementIter+import {-# SOURCE #-} GI.Poppler.Structs.TextAttributes+import {-# SOURCE #-} GI.Poppler.Structs.TextSpan+import {-# SOURCE #-} GI.Poppler.Unions.Action++import GI.Poppler.Enums+import GI.Poppler.Flags+
+ GI/Poppler/Unions.hs view
@@ -0,0 +1,26 @@++{- |+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.Unions+    (     module GI.Poppler.Unions.Action         ,+++    ) where++import GI.Poppler.Unions.Action++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Poppler.Types+import GI.Poppler.Callbacks++
+ GI/Poppler/Unions/Action.hs view
@@ -0,0 +1,212 @@++{- |+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.Unions.Action+    ( ++-- * Exported types+    Action(..)                              ,+    noAction                                ,+++ -- * Methods+-- ** actionCopy+    actionCopy                              ,+++-- ** actionFree+    actionFree                              ,+++++ -- * Properties+-- ** Any+    actionReadAny                           ,+++-- ** GotoDest+    actionReadGotoDest                      ,+++-- ** GotoRemote+    actionReadGotoRemote                    ,+++-- ** Javascript+    actionReadJavascript                    ,+++-- ** Launch+    actionReadLaunch                        ,+++-- ** Movie+    actionReadMovie                         ,+++-- ** Named+    actionReadNamed                         ,+++-- ** OcgState+    actionReadOcgState                      ,+++-- ** Rendition+    actionReadRendition                     ,+++-- ** Type+    actionReadType                          ,+++-- ** Uri+    actionReadUri                           ,+++++    ) where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++import GI.Poppler.Types+import GI.Poppler.Callbacks++newtype Action = Action (ForeignPtr Action)+foreign import ccall "poppler_action_get_type" c_poppler_action_get_type :: +    IO GType++instance BoxedObject Action where+    boxedType _ = c_poppler_action_get_type++noAction :: Maybe Action+noAction = Nothing++actionReadType :: Action -> IO ActionType+actionReadType s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO CUInt+    let val' = (toEnum . fromIntegral) val+    return val'++actionReadAny :: Action -> IO ActionAny+actionReadAny s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO (Ptr ActionAny)+    val' <- (newPtr 16 ActionAny) val+    return val'++actionReadGotoDest :: Action -> IO ActionGotoDest+actionReadGotoDest s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO (Ptr ActionGotoDest)+    val' <- (newPtr 24 ActionGotoDest) val+    return val'++actionReadGotoRemote :: Action -> IO ActionGotoRemote+actionReadGotoRemote s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO (Ptr ActionGotoRemote)+    val' <- (newPtr 32 ActionGotoRemote) val+    return val'++actionReadLaunch :: Action -> IO ActionLaunch+actionReadLaunch s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO (Ptr ActionLaunch)+    val' <- (newPtr 32 ActionLaunch) val+    return val'++actionReadUri :: Action -> IO ActionUri+actionReadUri s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO (Ptr ActionUri)+    val' <- (newPtr 24 ActionUri) val+    return val'++actionReadNamed :: Action -> IO ActionNamed+actionReadNamed s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO (Ptr ActionNamed)+    val' <- (newPtr 24 ActionNamed) val+    return val'++actionReadMovie :: Action -> IO ActionMovie+actionReadMovie s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO (Ptr ActionMovie)+    val' <- (newPtr 32 ActionMovie) val+    return val'++actionReadRendition :: Action -> IO ActionRendition+actionReadRendition s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO (Ptr ActionRendition)+    val' <- (newPtr 32 ActionRendition) val+    return val'++actionReadOcgState :: Action -> IO ActionOCGState+actionReadOcgState s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO (Ptr ActionOCGState)+    val' <- (newPtr 24 ActionOCGState) val+    return val'++actionReadJavascript :: Action -> IO ActionJavascript+actionReadJavascript s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO (Ptr ActionJavascript)+    val' <- (newPtr 24 ActionJavascript) val+    return val'++-- method Action::copy+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TInterface "Poppler" "Action"+-- throws : False+-- Skip return : False++foreign import ccall "poppler_action_copy" poppler_action_copy :: +    Ptr Action ->                           -- _obj : TInterface "Poppler" "Action"+    IO (Ptr Action)+++actionCopy ::+    (MonadIO m) =>+    Action ->                               -- _obj+    m Action+actionCopy _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- poppler_action_copy _obj'+    checkUnexpectedReturnNULL "poppler_action_copy" result+    result' <- (wrapBoxed Action) result+    touchManagedPtr _obj+    return result'++-- method Action::free+-- method type : OrdinaryMethod+-- Args : [Arg {argName = "_obj", argType = TInterface "Poppler" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- Lengths : []+-- hInArgs : [Arg {argName = "_obj", argType = TInterface "Poppler" "Action", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "poppler_action_free" poppler_action_free :: +    Ptr Action ->                           -- _obj : TInterface "Poppler" "Action"+    IO ()+++actionFree ::+    (MonadIO m) =>+    Action ->                               -- _obj+    m ()+actionFree _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    poppler_action_free _obj'+    touchManagedPtr _obj+    return ()++
+ GI/Poppler/Unions/Action.hs-boot view
@@ -0,0 +1,11 @@+module GI.Poppler.Unions.Action where++import Prelude ()+import Data.GI.Base.ShortPrelude++import qualified Data.Text as T+import qualified Data.ByteString.Char8 as B+import qualified Data.Map as Map++newtype Action = Action (ForeignPtr Action)+instance BoxedObject Action where
+ LICENSE view
@@ -0,0 +1,456 @@+                  GNU LESSER GENERAL PUBLIC LICENSE+                       Version 2.1, February 1999++ Copyright (C) 1991, 1999 Free Software Foundation, Inc.+ 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA+ Everyone is permitted to copy and distribute verbatim copies+ of this license document, but changing it is not allowed.++[This is the first released version of the Lesser GPL.  It also counts+ as the successor of the GNU Library Public License, version 2, hence+ the version number 2.1.]++                            Preamble++  The licenses for most software are designed to take away your+freedom to share and change it.  By contrast, the GNU General Public+Licenses are intended to guarantee your freedom to share and change+free software--to make sure the software is free for all its users.++  This license, the Lesser General Public License, applies to some+specially designated software packages--typically libraries--of the+Free Software Foundation and other authors who decide to use it.  You+can use it too, but we suggest you first think carefully about whether+this license or the ordinary General Public License is the better+strategy to use in any particular case, based on the explanations below.++  When we speak of free software, we are referring to freedom of use,+not price.  Our General Public Licenses are designed to make sure that+you have the freedom to distribute copies of free software (and charge+for this service if you wish); that you receive source code or can get+it if you want it; that you can change the software and use pieces of+it in new free programs; and that you are informed that you can do+these things.++  To protect your rights, we need to make restrictions that forbid+distributors to deny you these rights or to ask you to surrender these+rights.  These restrictions translate to certain responsibilities for+you if you distribute copies of the library or if you modify it.++  For example, if you distribute copies of the library, whether gratis+or for a fee, you must give the recipients all the rights that we gave+you.  You must make sure that they, too, receive or can get the source+code.  If you link other code with the library, you must provide+complete object files to the recipients, so that they can relink them+with the library after making changes to the library and recompiling+it.  And you must show them these terms so they know their rights.++  We protect your rights with a two-step method: (1) we copyright the+library, and (2) we offer you this license, which gives you legal+permission to copy, distribute and/or modify the library.++  To protect each distributor, we want to make it very clear that+there is no warranty for the free library.  Also, if the library is+modified by someone else and passed on, the recipients should know+that what they have is not the original version, so that the original+author's reputation will not be affected by problems that might be+introduced by others.++  Finally, software patents pose a constant threat to the existence of+any free program.  We wish to make sure that a company cannot+effectively restrict the users of a free program by obtaining a+restrictive license from a patent holder.  Therefore, we insist that+any patent license obtained for a version of the library must be+consistent with the full freedom of use specified in this license.++  Most GNU software, including some libraries, is covered by the+ordinary GNU General Public License.  This license, the GNU Lesser+General Public License, applies to certain designated libraries, and+is quite different from the ordinary General Public License.  We use+this license for certain libraries in order to permit linking those+libraries into non-free programs.++  When a program is linked with a library, whether statically or using+a shared library, the combination of the two is legally speaking a+combined work, a derivative of the original library.  The ordinary+General Public License therefore permits such linking only if the+entire combination fits its criteria of freedom.  The Lesser General+Public License permits more lax criteria for linking other code with+the library.++  We call this license the "Lesser" General Public License because it+does Less to protect the user's freedom than the ordinary General+Public License.  It also provides other free software developers Less+of an advantage over competing non-free programs.  These disadvantages+are the reason we use the ordinary General Public License for many+libraries.  However, the Lesser license provides advantages in certain+special circumstances.++  For example, on rare occasions, there may be a special need to+encourage the widest possible use of a certain library, so that it becomes+a de-facto standard.  To achieve this, non-free programs must be+allowed to use the library.  A more frequent case is that a free+library does the same job as widely used non-free libraries.  In this+case, there is little to gain by limiting the free library to free+software only, so we use the Lesser General Public License.++  In other cases, permission to use a particular library in non-free+programs enables a greater number of people to use a large body of+free software.  For example, permission to use the GNU C Library in+non-free programs enables many more people to use the whole GNU+operating system, as well as its variant, the GNU/Linux operating+system.++  Although the Lesser General Public License is Less protective of the+users' freedom, it does ensure that the user of a program that is+linked with the Library has the freedom and the wherewithal to run+that program using a modified version of the Library.++  The precise terms and conditions for copying, distribution and+modification follow.  Pay close attention to the difference between a+"work based on the library" and a "work that uses the library".  The+former contains code derived from the library, whereas the latter must+be combined with the library in order to run.++                  GNU LESSER GENERAL PUBLIC LICENSE+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION++  0. This License Agreement applies to any software library or other+program which contains a notice placed by the copyright holder or+other authorized party saying it may be distributed under the terms of+this Lesser General Public License (also called "this License").+Each licensee is addressed as "you".++  A "library" means a collection of software functions and/or data+prepared so as to be conveniently linked with application programs+(which use some of those functions and data) to form executables.++  The "Library", below, refers to any such software library or work+which has been distributed under these terms.  A "work based on the+Library" means either the Library or any derivative work under+copyright law: that is to say, a work containing the Library or a+portion of it, either verbatim or with modifications and/or translated+straightforwardly into another language.  (Hereinafter, translation is+included without limitation in the term "modification".)++  "Source code" for a work means the preferred form of the work for+making modifications to it.  For a library, complete source code means+all the source code for all modules it contains, plus any associated+interface definition files, plus the scripts used to control compilation+and installation of the library.++  Activities other than copying, distribution and modification are not+covered by this License; they are outside its scope.  The act of+running a program using the Library is not restricted, and output from+such a program is covered only if its contents constitute a work based+on the Library (independent of the use of the Library in a tool for+writing it).  Whether that is true depends on what the Library does+and what the program that uses the Library does.++  1. You may copy and distribute verbatim copies of the Library's+complete source code as you receive it, in any medium, provided that+you conspicuously and appropriately publish on each copy an+appropriate copyright notice and disclaimer of warranty; keep intact+all the notices that refer to this License and to the absence of any+warranty; and distribute a copy of this License along with the+Library.++  You may charge a fee for the physical act of transferring a copy,+and you may at your option offer warranty protection in exchange for a+fee.++  2. You may modify your copy or copies of the Library or any portion+of it, thus forming a work based on the Library, and copy and+distribute such modifications or work under the terms of Section 1+above, provided that you also meet all of these conditions:++    a) The modified work must itself be a software library.++    b) You must cause the files modified to carry prominent notices+    stating that you changed the files and the date of any change.++    c) You must cause the whole of the work to be licensed at no+    charge to all third parties under the terms of this License.++    d) If a facility in the modified Library refers to a function or a+    table of data to be supplied by an application program that uses+    the facility, other than as an argument passed when the facility+    is invoked, then you must make a good faith effort to ensure that,+    in the event an application does not supply such function or+    table, the facility still operates, and performs whatever part of+    its purpose remains meaningful.++    (For example, a function in a library to compute square roots has+    a purpose that is entirely well-defined independent of the+    application.  Therefore, Subsection 2d requires that any+    application-supplied function or table used by this function must+    be optional: if the application does not supply it, the square+    root function must still compute square roots.)++These requirements apply to the modified work as a whole.  If+identifiable sections of that work are not derived from the Library,+and can be reasonably considered independent and separate works in+themselves, then this License, and its terms, do not apply to those+sections when you distribute them as separate works.  But when you+distribute the same sections as part of a whole which is a work based+on the Library, the distribution of the whole must be on the terms of+this License, whose permissions for other licensees extend to the+entire whole, and thus to each and every part regardless of who wrote+it.++Thus, it is not the intent of this section to claim rights or contest+your rights to work written entirely by you; rather, the intent is to+exercise the right to control the distribution of derivative or+collective works based on the Library.++In addition, mere aggregation of another work not based on the Library+with the Library (or with a work based on the Library) on a volume of+a storage or distribution medium does not bring the other work under+the scope of this License.++  3. You may opt to apply the terms of the ordinary GNU General Public+License instead of this License to a given copy of the Library.  To do+this, you must alter all the notices that refer to this License, so+that they refer to the ordinary GNU General Public License, version 2,+instead of to this License.  (If a newer version than version 2 of the+ordinary GNU General Public License has appeared, then you can specify+that version instead if you wish.)  Do not make any other change in+these notices.++  Once this change is made in a given copy, it is irreversible for+that copy, so the ordinary GNU General Public License applies to all+subsequent copies and derivative works made from that copy.++  This option is useful when you wish to copy part of the code of+the Library into a program that is not a library.++  4. You may copy and distribute the Library (or a portion or+derivative of it, under Section 2) in object code or executable form+under the terms of Sections 1 and 2 above provided that you accompany+it with the complete corresponding machine-readable source code, which+must be distributed under the terms of Sections 1 and 2 above on a+medium customarily used for software interchange.++  If distribution of object code is made by offering access to copy+from a designated place, then offering equivalent access to copy the+source code from the same place satisfies the requirement to+distribute the source code, even though third parties are not+compelled to copy the source along with the object code.++  5. A program that contains no derivative of any portion of the+Library, but is designed to work with the Library by being compiled or+linked with it, is called a "work that uses the Library".  Such a+work, in isolation, is not a derivative work of the Library, and+therefore falls outside the scope of this License.++  However, linking a "work that uses the Library" with the Library+creates an executable that is a derivative of the Library (because it+contains portions of the Library), rather than a "work that uses the+library".  The executable is therefore covered by this License.+Section 6 states terms for distribution of such executables.++  When a "work that uses the Library" uses material from a header file+that is part of the Library, the object code for the work may be a+derivative work of the Library even though the source code is not.+Whether this is true is especially significant if the work can be+linked without the Library, or if the work is itself a library.  The+threshold for this to be true is not precisely defined by law.++  If such an object file uses only numerical parameters, data+structure layouts and accessors, and small macros and small inline+functions (ten lines or less in length), then the use of the object+file is unrestricted, regardless of whether it is legally a derivative+work.  (Executables containing this object code plus portions of the+Library will still fall under Section 6.)++  Otherwise, if the work is a derivative of the Library, you may+distribute the object code for the work under the terms of Section 6.+Any executables containing that work also fall under Section 6,+whether or not they are linked directly with the Library itself.++  6. As an exception to the Sections above, you may also combine or+link a "work that uses the Library" with the Library to produce a+work containing portions of the Library, and distribute that work+under terms of your choice, provided that the terms permit+modification of the work for the customer's own use and reverse+engineering for debugging such modifications.++  You must give prominent notice with each copy of the work that the+Library is used in it and that the Library and its use are covered by+this License.  You must supply a copy of this License.  If the work+during execution displays copyright notices, you must include the+copyright notice for the Library among them, as well as a reference+directing the user to the copy of this License.  Also, you must do one+of these things:++    a) Accompany the work with the complete corresponding+    machine-readable source code for the Library including whatever+    changes were used in the work (which must be distributed under+    Sections 1 and 2 above); and, if the work is an executable linked+    with the Library, with the complete machine-readable "work that+    uses the Library", as object code and/or source code, so that the+    user can modify the Library and then relink to produce a modified+    executable containing the modified Library.  (It is understood+    that the user who changes the contents of definitions files in the+    Library will not necessarily be able to recompile the application+    to use the modified definitions.)++    b) Use a suitable shared library mechanism for linking with the+    Library.  A suitable mechanism is one that (1) uses at run time a+    copy of the library already present on the user's computer system,+    rather than copying library functions into the executable, and (2)+    will operate properly with a modified version of the library, if+    the user installs one, as long as the modified version is+    interface-compatible with the version that the work was made with.++    c) Accompany the work with a written offer, valid for at+    least three years, to give the same user the materials+    specified in Subsection 6a, above, for a charge no more+    than the cost of performing this distribution.++    d) If distribution of the work is made by offering access to copy+    from a designated place, offer equivalent access to copy the above+    specified materials from the same place.++    e) Verify that the user has already received a copy of these+    materials or that you have already sent this user a copy.++  For an executable, the required form of the "work that uses the+Library" must include any data and utility programs needed for+reproducing the executable from it.  However, as a special exception,+the materials to be distributed need not include anything that is+normally distributed (in either source or binary form) with the major+components (compiler, kernel, and so on) of the operating system on+which the executable runs, unless that component itself accompanies+the executable.++  It may happen that this requirement contradicts the license+restrictions of other proprietary libraries that do not normally+accompany the operating system.  Such a contradiction means you cannot+use both them and the Library together in an executable that you+distribute.++  7. You may place library facilities that are a work based on the+Library side-by-side in a single library together with other library+facilities not covered by this License, and distribute such a combined+library, provided that the separate distribution of the work based on+the Library and of the other library facilities is otherwise+permitted, and provided that you do these two things:++    a) Accompany the combined library with a copy of the same work+    based on the Library, uncombined with any other library+    facilities.  This must be distributed under the terms of the+    Sections above.++    b) Give prominent notice with the combined library of the fact+    that part of it is a work based on the Library, and explaining+    where to find the accompanying uncombined form of the same work.++  8. You may not copy, modify, sublicense, link with, or distribute+the Library except as expressly provided under this License.  Any+attempt otherwise to copy, modify, sublicense, link with, or+distribute the Library is void, and will automatically terminate your+rights under this License.  However, parties who have received copies,+or rights, from you under this License will not have their licenses+terminated so long as such parties remain in full compliance.++  9. You are not required to accept this License, since you have not+signed it.  However, nothing else grants you permission to modify or+distribute the Library or its derivative works.  These actions are+prohibited by law if you do not accept this License.  Therefore, by+modifying or distributing the Library (or any work based on the+Library), you indicate your acceptance of this License to do so, and+all its terms and conditions for copying, distributing or modifying+the Library or works based on it.++  10. Each time you redistribute the Library (or any work based on the+Library), the recipient automatically receives a license from the+original licensor to copy, distribute, link with or modify the Library+subject to these terms and conditions.  You may not impose any further+restrictions on the recipients' exercise of the rights granted herein.+You are not responsible for enforcing compliance by third parties with+this License.++  11. If, as a consequence of a court judgment or allegation of patent+infringement or for any other reason (not limited to patent issues),+conditions are imposed on you (whether by court order, agreement or+otherwise) that contradict the conditions of this License, they do not+excuse you from the conditions of this License.  If you cannot+distribute so as to satisfy simultaneously your obligations under this+License and any other pertinent obligations, then as a consequence you+may not distribute the Library at all.  For example, if a patent+license would not permit royalty-free redistribution of the Library by+all those who receive copies directly or indirectly through you, then+the only way you could satisfy both it and this License would be to+refrain entirely from distribution of the Library.++If any portion of this section is held invalid or unenforceable under any+particular circumstance, the balance of the section is intended to apply,+and the section as a whole is intended to apply in other circumstances.++It is not the purpose of this section to induce you to infringe any+patents or other property right claims or to contest validity of any+such claims; this section has the sole purpose of protecting the+integrity of the free software distribution system which is+implemented by public license practices.  Many people have made+generous contributions to the wide range of software distributed+through that system in reliance on consistent application of that+system; it is up to the author/donor to decide if he or she is willing+to distribute software through any other system and a licensee cannot+impose that choice.++This section is intended to make thoroughly clear what is believed to+be a consequence of the rest of this License.++  12. If the distribution and/or use of the Library is restricted in+certain countries either by patents or by copyrighted interfaces, the+original copyright holder who places the Library under this License may add+an explicit geographical distribution limitation excluding those countries,+so that distribution is permitted only in or among countries not thus+excluded.  In such case, this License incorporates the limitation as if+written in the body of this License.++  13. The Free Software Foundation may publish revised and/or new+versions of the Lesser General Public License from time to time.+Such new versions will be similar in spirit to the present version,+but may differ in detail to address new problems or concerns.++Each version is given a distinguishing version number.  If the Library+specifies a version number of this License which applies to it and+"any later version", you have the option of following the terms and+conditions either of that version or of any later version published by+the Free Software Foundation.  If the Library does not specify a+license version number, you may choose any version ever published by+the Free Software Foundation.++  14. If you wish to incorporate parts of the Library into other free+programs whose distribution conditions are incompatible with these,+write to the author to ask for permission.  For software which is+copyrighted by the Free Software Foundation, write to the Free+Software Foundation; we sometimes make exceptions for this.  Our+decision will be guided by the two goals of preserving the free status+of all derivatives of our free software and of promoting the sharing+and reuse of software generally.++                            NO WARRANTY++  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.++  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH+DAMAGES.
+ Setup.hs view
@@ -0,0 +1,3 @@+#!/usr/bin/env runhaskell+import Distribution.Simple+main = defaultMain
+ gi-poppler.cabal view
@@ -0,0 +1,90 @@+-- Autogenerated, do not edit.+name:               gi-poppler+version:            0.0.30.12+synopsis:           Poppler bindings+description:        Bindings for Poppler, autogenerated by haskell-gi.+homepage:           https://github.com/haskell-gi/haskell-gi+license:            LGPL-2.1+license-file:       LICENSE+author:             Will Thompson, Iñaki García Etxebarria and Jonas Platte+maintainer:         Iñaki García Etxebarria (garetxe@gmail.com)+category:           Bindings+build-type:         Simple+cabal-version:      >=1.10++library+    default-language:   Haskell2010+    default-extensions: OverloadedStrings, NegativeLiterals, ConstraintKinds, TypeFamilies, MultiParamTypeClasses, KindSignatures, FlexibleInstances, UndecidableInstances, DataKinds, FlexibleContexts+    other-extensions:   PatternSynonyms ScopedTypeVariables, ViewPatterns+    ghc-options:        -fno-warn-unused-imports -fno-warn-warnings-deprecations+    exposed-modules:    GI.Poppler.Types+                        GI.Poppler+                        GI.Poppler.Callbacks+                        GI.Poppler.Constants+                        GI.Poppler.Enums+                        GI.Poppler.Flags+                        GI.Poppler.Functions+                        GI.Poppler.Objects+                        GI.Poppler.Objects.Annot+                        GI.Poppler.Objects.AnnotCircle+                        GI.Poppler.Objects.AnnotFileAttachment+                        GI.Poppler.Objects.AnnotFreeText+                        GI.Poppler.Objects.AnnotLine+                        GI.Poppler.Objects.AnnotMarkup+                        GI.Poppler.Objects.AnnotMovie+                        GI.Poppler.Objects.AnnotScreen+                        GI.Poppler.Objects.AnnotSquare+                        GI.Poppler.Objects.AnnotText+                        GI.Poppler.Objects.AnnotTextMarkup+                        GI.Poppler.Objects.Attachment+                        GI.Poppler.Objects.Document+                        GI.Poppler.Objects.FontInfo+                        GI.Poppler.Objects.FormField+                        GI.Poppler.Objects.Layer+                        GI.Poppler.Objects.Media+                        GI.Poppler.Objects.Movie+                        GI.Poppler.Objects.PSFile+                        GI.Poppler.Objects.Page+                        GI.Poppler.Objects.StructureElement+                        GI.Poppler.Structs+                        GI.Poppler.Structs.ActionAny+                        GI.Poppler.Structs.ActionGotoDest+                        GI.Poppler.Structs.ActionGotoRemote+                        GI.Poppler.Structs.ActionJavascript+                        GI.Poppler.Structs.ActionLaunch+                        GI.Poppler.Structs.ActionLayer+                        GI.Poppler.Structs.ActionMovie+                        GI.Poppler.Structs.ActionNamed+                        GI.Poppler.Structs.ActionOCGState+                        GI.Poppler.Structs.ActionRendition+                        GI.Poppler.Structs.ActionUri+                        GI.Poppler.Structs.AnnotCalloutLine+                        GI.Poppler.Structs.AnnotMapping+                        GI.Poppler.Structs.Color+                        GI.Poppler.Structs.Dest+                        GI.Poppler.Structs.FontsIter+                        GI.Poppler.Structs.FormFieldMapping+                        GI.Poppler.Structs.ImageMapping+                        GI.Poppler.Structs.IndexIter+                        GI.Poppler.Structs.LayersIter+                        GI.Poppler.Structs.LinkMapping+                        GI.Poppler.Structs.PageTransition+                        GI.Poppler.Structs.Point+                        GI.Poppler.Structs.Quadrilateral+                        GI.Poppler.Structs.Rectangle+                        GI.Poppler.Structs.StructureElementIter+                        GI.Poppler.Structs.TextAttributes+                        GI.Poppler.Structs.TextSpan+                        GI.Poppler.Unions+                        GI.Poppler.Unions.Action+    pkgconfig-depends:  poppler-glib >= 0.30+    build-depends: base >= 4.7 && <5,+        haskell-gi-base >= 0.12 && < 1,+        gi-glib >= 0.2.44.12 && < 0.2.45,+        gi-gobject >= 0.2.44.12 && < 0.2.45,+        gi-gio >= 0.2.44.12 && < 0.2.45,+        gi-cairo >= 0.1.14.12 && < 0.1.15,+        bytestring >= 0.10,+        containers >= 0.5,+        text >= 1.0,+        transformers >= 0.3