diff --git a/GI/Poppler.hs b/GI/Poppler.hs new file mode 100644 --- /dev/null +++ b/GI/Poppler.hs @@ -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 + + diff --git a/GI/Poppler/Callbacks.hs b/GI/Poppler/Callbacks.hs new file mode 100644 --- /dev/null +++ b/GI/Poppler/Callbacks.hs @@ -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' + + diff --git a/GI/Poppler/Constants.hs b/GI/Poppler/Constants.hs new file mode 100644 --- /dev/null +++ b/GI/Poppler/Constants.hs @@ -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 + + diff --git a/GI/Poppler/Enums.hs b/GI/Poppler/Enums.hs new file mode 100644 --- /dev/null +++ b/GI/Poppler/Enums.hs @@ -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 + + diff --git a/GI/Poppler/Flags.hs b/GI/Poppler/Flags.hs new file mode 100644 --- /dev/null +++ b/GI/Poppler/Flags.hs @@ -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 + + diff --git a/GI/Poppler/Functions.hs b/GI/Poppler/Functions.hs new file mode 100644 --- /dev/null +++ b/GI/Poppler/Functions.hs @@ -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' + + + diff --git a/GI/Poppler/Objects.hs b/GI/Poppler/Objects.hs new file mode 100644 --- /dev/null +++ b/GI/Poppler/Objects.hs @@ -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 + + diff --git a/GI/Poppler/Objects/Annot.hs b/GI/Poppler/Objects/Annot.hs new file mode 100644 --- /dev/null +++ b/GI/Poppler/Objects/Annot.hs @@ -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 () + + diff --git a/GI/Poppler/Objects/Annot.hs-boot b/GI/Poppler/Objects/Annot.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Poppler/Objects/Annot.hs-boot @@ -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 diff --git a/GI/Poppler/Objects/AnnotCircle.hs b/GI/Poppler/Objects/AnnotCircle.hs new file mode 100644 --- /dev/null +++ b/GI/Poppler/Objects/AnnotCircle.hs @@ -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 () + + diff --git a/GI/Poppler/Objects/AnnotCircle.hs-boot b/GI/Poppler/Objects/AnnotCircle.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Poppler/Objects/AnnotCircle.hs-boot @@ -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 diff --git a/GI/Poppler/Objects/AnnotFileAttachment.hs b/GI/Poppler/Objects/AnnotFileAttachment.hs new file mode 100644 --- /dev/null +++ b/GI/Poppler/Objects/AnnotFileAttachment.hs @@ -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' + + diff --git a/GI/Poppler/Objects/AnnotFileAttachment.hs-boot b/GI/Poppler/Objects/AnnotFileAttachment.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Poppler/Objects/AnnotFileAttachment.hs-boot @@ -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 diff --git a/GI/Poppler/Objects/AnnotFreeText.hs b/GI/Poppler/Objects/AnnotFreeText.hs new file mode 100644 --- /dev/null +++ b/GI/Poppler/Objects/AnnotFreeText.hs @@ -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' + + diff --git a/GI/Poppler/Objects/AnnotFreeText.hs-boot b/GI/Poppler/Objects/AnnotFreeText.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Poppler/Objects/AnnotFreeText.hs-boot @@ -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 diff --git a/GI/Poppler/Objects/AnnotLine.hs b/GI/Poppler/Objects/AnnotLine.hs new file mode 100644 --- /dev/null +++ b/GI/Poppler/Objects/AnnotLine.hs @@ -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 () + + diff --git a/GI/Poppler/Objects/AnnotLine.hs-boot b/GI/Poppler/Objects/AnnotLine.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Poppler/Objects/AnnotLine.hs-boot @@ -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 diff --git a/GI/Poppler/Objects/AnnotMarkup.hs b/GI/Poppler/Objects/AnnotMarkup.hs new file mode 100644 --- /dev/null +++ b/GI/Poppler/Objects/AnnotMarkup.hs @@ -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 () + + diff --git a/GI/Poppler/Objects/AnnotMarkup.hs-boot b/GI/Poppler/Objects/AnnotMarkup.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Poppler/Objects/AnnotMarkup.hs-boot @@ -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 diff --git a/GI/Poppler/Objects/AnnotMovie.hs b/GI/Poppler/Objects/AnnotMovie.hs new file mode 100644 --- /dev/null +++ b/GI/Poppler/Objects/AnnotMovie.hs @@ -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' + + diff --git a/GI/Poppler/Objects/AnnotMovie.hs-boot b/GI/Poppler/Objects/AnnotMovie.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Poppler/Objects/AnnotMovie.hs-boot @@ -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 diff --git a/GI/Poppler/Objects/AnnotScreen.hs b/GI/Poppler/Objects/AnnotScreen.hs new file mode 100644 --- /dev/null +++ b/GI/Poppler/Objects/AnnotScreen.hs @@ -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' + + diff --git a/GI/Poppler/Objects/AnnotScreen.hs-boot b/GI/Poppler/Objects/AnnotScreen.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Poppler/Objects/AnnotScreen.hs-boot @@ -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 diff --git a/GI/Poppler/Objects/AnnotSquare.hs b/GI/Poppler/Objects/AnnotSquare.hs new file mode 100644 --- /dev/null +++ b/GI/Poppler/Objects/AnnotSquare.hs @@ -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 () + + diff --git a/GI/Poppler/Objects/AnnotSquare.hs-boot b/GI/Poppler/Objects/AnnotSquare.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Poppler/Objects/AnnotSquare.hs-boot @@ -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 diff --git a/GI/Poppler/Objects/AnnotText.hs b/GI/Poppler/Objects/AnnotText.hs new file mode 100644 --- /dev/null +++ b/GI/Poppler/Objects/AnnotText.hs @@ -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 () + + diff --git a/GI/Poppler/Objects/AnnotText.hs-boot b/GI/Poppler/Objects/AnnotText.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Poppler/Objects/AnnotText.hs-boot @@ -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 diff --git a/GI/Poppler/Objects/AnnotTextMarkup.hs b/GI/Poppler/Objects/AnnotTextMarkup.hs new file mode 100644 --- /dev/null +++ b/GI/Poppler/Objects/AnnotTextMarkup.hs @@ -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 () + + diff --git a/GI/Poppler/Objects/AnnotTextMarkup.hs-boot b/GI/Poppler/Objects/AnnotTextMarkup.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Poppler/Objects/AnnotTextMarkup.hs-boot @@ -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 diff --git a/GI/Poppler/Objects/Attachment.hs b/GI/Poppler/Objects/Attachment.hs new file mode 100644 --- /dev/null +++ b/GI/Poppler/Objects/Attachment.hs @@ -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 () + ) + + diff --git a/GI/Poppler/Objects/Attachment.hs-boot b/GI/Poppler/Objects/Attachment.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Poppler/Objects/Attachment.hs-boot @@ -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 diff --git a/GI/Poppler/Objects/Document.hs b/GI/Poppler/Objects/Document.hs new file mode 100644 --- /dev/null +++ b/GI/Poppler/Objects/Document.hs @@ -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' + ) + + diff --git a/GI/Poppler/Objects/Document.hs-boot b/GI/Poppler/Objects/Document.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Poppler/Objects/Document.hs-boot @@ -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 diff --git a/GI/Poppler/Objects/FontInfo.hs b/GI/Poppler/Objects/FontInfo.hs new file mode 100644 --- /dev/null +++ b/GI/Poppler/Objects/FontInfo.hs @@ -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'') + + diff --git a/GI/Poppler/Objects/FontInfo.hs-boot b/GI/Poppler/Objects/FontInfo.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Poppler/Objects/FontInfo.hs-boot @@ -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 diff --git a/GI/Poppler/Objects/FormField.hs b/GI/Poppler/Objects/FormField.hs new file mode 100644 --- /dev/null +++ b/GI/Poppler/Objects/FormField.hs @@ -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 () + + diff --git a/GI/Poppler/Objects/FormField.hs-boot b/GI/Poppler/Objects/FormField.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Poppler/Objects/FormField.hs-boot @@ -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 diff --git a/GI/Poppler/Objects/Layer.hs b/GI/Poppler/Objects/Layer.hs new file mode 100644 --- /dev/null +++ b/GI/Poppler/Objects/Layer.hs @@ -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 () + + diff --git a/GI/Poppler/Objects/Layer.hs-boot b/GI/Poppler/Objects/Layer.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Poppler/Objects/Layer.hs-boot @@ -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 diff --git a/GI/Poppler/Objects/Media.hs b/GI/Poppler/Objects/Media.hs new file mode 100644 --- /dev/null +++ b/GI/Poppler/Objects/Media.hs @@ -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 () + ) + + diff --git a/GI/Poppler/Objects/Media.hs-boot b/GI/Poppler/Objects/Media.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Poppler/Objects/Media.hs-boot @@ -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 diff --git a/GI/Poppler/Objects/Movie.hs b/GI/Poppler/Objects/Movie.hs new file mode 100644 --- /dev/null +++ b/GI/Poppler/Objects/Movie.hs @@ -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' + + diff --git a/GI/Poppler/Objects/Movie.hs-boot b/GI/Poppler/Objects/Movie.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Poppler/Objects/Movie.hs-boot @@ -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 diff --git a/GI/Poppler/Objects/PSFile.hs b/GI/Poppler/Objects/PSFile.hs new file mode 100644 --- /dev/null +++ b/GI/Poppler/Objects/PSFile.hs @@ -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 () + + diff --git a/GI/Poppler/Objects/PSFile.hs-boot b/GI/Poppler/Objects/PSFile.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Poppler/Objects/PSFile.hs-boot @@ -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 diff --git a/GI/Poppler/Objects/Page.hs b/GI/Poppler/Objects/Page.hs new file mode 100644 --- /dev/null +++ b/GI/Poppler/Objects/Page.hs @@ -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 () + + diff --git a/GI/Poppler/Objects/Page.hs-boot b/GI/Poppler/Objects/Page.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Poppler/Objects/Page.hs-boot @@ -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 diff --git a/GI/Poppler/Objects/StructureElement.hs b/GI/Poppler/Objects/StructureElement.hs new file mode 100644 --- /dev/null +++ b/GI/Poppler/Objects/StructureElement.hs @@ -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' + + diff --git a/GI/Poppler/Objects/StructureElement.hs-boot b/GI/Poppler/Objects/StructureElement.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Poppler/Objects/StructureElement.hs-boot @@ -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 diff --git a/GI/Poppler/Structs.hs b/GI/Poppler/Structs.hs new file mode 100644 --- /dev/null +++ b/GI/Poppler/Structs.hs @@ -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 + + diff --git a/GI/Poppler/Structs/ActionAny.hs b/GI/Poppler/Structs/ActionAny.hs new file mode 100644 --- /dev/null +++ b/GI/Poppler/Structs/ActionAny.hs @@ -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' + + diff --git a/GI/Poppler/Structs/ActionAny.hs-boot b/GI/Poppler/Structs/ActionAny.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Poppler/Structs/ActionAny.hs-boot @@ -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) diff --git a/GI/Poppler/Structs/ActionGotoDest.hs b/GI/Poppler/Structs/ActionGotoDest.hs new file mode 100644 --- /dev/null +++ b/GI/Poppler/Structs/ActionGotoDest.hs @@ -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' + + diff --git a/GI/Poppler/Structs/ActionGotoDest.hs-boot b/GI/Poppler/Structs/ActionGotoDest.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Poppler/Structs/ActionGotoDest.hs-boot @@ -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) diff --git a/GI/Poppler/Structs/ActionGotoRemote.hs b/GI/Poppler/Structs/ActionGotoRemote.hs new file mode 100644 --- /dev/null +++ b/GI/Poppler/Structs/ActionGotoRemote.hs @@ -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' + + diff --git a/GI/Poppler/Structs/ActionGotoRemote.hs-boot b/GI/Poppler/Structs/ActionGotoRemote.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Poppler/Structs/ActionGotoRemote.hs-boot @@ -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) diff --git a/GI/Poppler/Structs/ActionJavascript.hs b/GI/Poppler/Structs/ActionJavascript.hs new file mode 100644 --- /dev/null +++ b/GI/Poppler/Structs/ActionJavascript.hs @@ -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' + + diff --git a/GI/Poppler/Structs/ActionJavascript.hs-boot b/GI/Poppler/Structs/ActionJavascript.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Poppler/Structs/ActionJavascript.hs-boot @@ -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) diff --git a/GI/Poppler/Structs/ActionLaunch.hs b/GI/Poppler/Structs/ActionLaunch.hs new file mode 100644 --- /dev/null +++ b/GI/Poppler/Structs/ActionLaunch.hs @@ -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' + + diff --git a/GI/Poppler/Structs/ActionLaunch.hs-boot b/GI/Poppler/Structs/ActionLaunch.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Poppler/Structs/ActionLaunch.hs-boot @@ -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) diff --git a/GI/Poppler/Structs/ActionLayer.hs b/GI/Poppler/Structs/ActionLayer.hs new file mode 100644 --- /dev/null +++ b/GI/Poppler/Structs/ActionLayer.hs @@ -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' + + diff --git a/GI/Poppler/Structs/ActionLayer.hs-boot b/GI/Poppler/Structs/ActionLayer.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Poppler/Structs/ActionLayer.hs-boot @@ -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) diff --git a/GI/Poppler/Structs/ActionMovie.hs b/GI/Poppler/Structs/ActionMovie.hs new file mode 100644 --- /dev/null +++ b/GI/Poppler/Structs/ActionMovie.hs @@ -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' + + diff --git a/GI/Poppler/Structs/ActionMovie.hs-boot b/GI/Poppler/Structs/ActionMovie.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Poppler/Structs/ActionMovie.hs-boot @@ -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) diff --git a/GI/Poppler/Structs/ActionNamed.hs b/GI/Poppler/Structs/ActionNamed.hs new file mode 100644 --- /dev/null +++ b/GI/Poppler/Structs/ActionNamed.hs @@ -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' + + diff --git a/GI/Poppler/Structs/ActionNamed.hs-boot b/GI/Poppler/Structs/ActionNamed.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Poppler/Structs/ActionNamed.hs-boot @@ -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) diff --git a/GI/Poppler/Structs/ActionOCGState.hs b/GI/Poppler/Structs/ActionOCGState.hs new file mode 100644 --- /dev/null +++ b/GI/Poppler/Structs/ActionOCGState.hs @@ -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' + + diff --git a/GI/Poppler/Structs/ActionOCGState.hs-boot b/GI/Poppler/Structs/ActionOCGState.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Poppler/Structs/ActionOCGState.hs-boot @@ -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) diff --git a/GI/Poppler/Structs/ActionRendition.hs b/GI/Poppler/Structs/ActionRendition.hs new file mode 100644 --- /dev/null +++ b/GI/Poppler/Structs/ActionRendition.hs @@ -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' + + diff --git a/GI/Poppler/Structs/ActionRendition.hs-boot b/GI/Poppler/Structs/ActionRendition.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Poppler/Structs/ActionRendition.hs-boot @@ -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) diff --git a/GI/Poppler/Structs/ActionUri.hs b/GI/Poppler/Structs/ActionUri.hs new file mode 100644 --- /dev/null +++ b/GI/Poppler/Structs/ActionUri.hs @@ -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' + + diff --git a/GI/Poppler/Structs/ActionUri.hs-boot b/GI/Poppler/Structs/ActionUri.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Poppler/Structs/ActionUri.hs-boot @@ -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) diff --git a/GI/Poppler/Structs/AnnotCalloutLine.hs b/GI/Poppler/Structs/AnnotCalloutLine.hs new file mode 100644 --- /dev/null +++ b/GI/Poppler/Structs/AnnotCalloutLine.hs @@ -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 () + + diff --git a/GI/Poppler/Structs/AnnotCalloutLine.hs-boot b/GI/Poppler/Structs/AnnotCalloutLine.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Poppler/Structs/AnnotCalloutLine.hs-boot @@ -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 diff --git a/GI/Poppler/Structs/AnnotMapping.hs b/GI/Poppler/Structs/AnnotMapping.hs new file mode 100644 --- /dev/null +++ b/GI/Poppler/Structs/AnnotMapping.hs @@ -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 () + + diff --git a/GI/Poppler/Structs/AnnotMapping.hs-boot b/GI/Poppler/Structs/AnnotMapping.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Poppler/Structs/AnnotMapping.hs-boot @@ -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 diff --git a/GI/Poppler/Structs/Color.hs b/GI/Poppler/Structs/Color.hs new file mode 100644 --- /dev/null +++ b/GI/Poppler/Structs/Color.hs @@ -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 () + + diff --git a/GI/Poppler/Structs/Color.hs-boot b/GI/Poppler/Structs/Color.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Poppler/Structs/Color.hs-boot @@ -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 diff --git a/GI/Poppler/Structs/Dest.hs b/GI/Poppler/Structs/Dest.hs new file mode 100644 --- /dev/null +++ b/GI/Poppler/Structs/Dest.hs @@ -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 () + + diff --git a/GI/Poppler/Structs/Dest.hs-boot b/GI/Poppler/Structs/Dest.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Poppler/Structs/Dest.hs-boot @@ -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 diff --git a/GI/Poppler/Structs/FontsIter.hs b/GI/Poppler/Structs/FontsIter.hs new file mode 100644 --- /dev/null +++ b/GI/Poppler/Structs/FontsIter.hs @@ -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' + + diff --git a/GI/Poppler/Structs/FontsIter.hs-boot b/GI/Poppler/Structs/FontsIter.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Poppler/Structs/FontsIter.hs-boot @@ -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 diff --git a/GI/Poppler/Structs/FormFieldMapping.hs b/GI/Poppler/Structs/FormFieldMapping.hs new file mode 100644 --- /dev/null +++ b/GI/Poppler/Structs/FormFieldMapping.hs @@ -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 () + + diff --git a/GI/Poppler/Structs/FormFieldMapping.hs-boot b/GI/Poppler/Structs/FormFieldMapping.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Poppler/Structs/FormFieldMapping.hs-boot @@ -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 diff --git a/GI/Poppler/Structs/ImageMapping.hs b/GI/Poppler/Structs/ImageMapping.hs new file mode 100644 --- /dev/null +++ b/GI/Poppler/Structs/ImageMapping.hs @@ -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 () + + diff --git a/GI/Poppler/Structs/ImageMapping.hs-boot b/GI/Poppler/Structs/ImageMapping.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Poppler/Structs/ImageMapping.hs-boot @@ -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 diff --git a/GI/Poppler/Structs/IndexIter.hs b/GI/Poppler/Structs/IndexIter.hs new file mode 100644 --- /dev/null +++ b/GI/Poppler/Structs/IndexIter.hs @@ -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' + + diff --git a/GI/Poppler/Structs/IndexIter.hs-boot b/GI/Poppler/Structs/IndexIter.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Poppler/Structs/IndexIter.hs-boot @@ -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 diff --git a/GI/Poppler/Structs/LayersIter.hs b/GI/Poppler/Structs/LayersIter.hs new file mode 100644 --- /dev/null +++ b/GI/Poppler/Structs/LayersIter.hs @@ -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' + + diff --git a/GI/Poppler/Structs/LayersIter.hs-boot b/GI/Poppler/Structs/LayersIter.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Poppler/Structs/LayersIter.hs-boot @@ -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 diff --git a/GI/Poppler/Structs/LinkMapping.hs b/GI/Poppler/Structs/LinkMapping.hs new file mode 100644 --- /dev/null +++ b/GI/Poppler/Structs/LinkMapping.hs @@ -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 () + + diff --git a/GI/Poppler/Structs/LinkMapping.hs-boot b/GI/Poppler/Structs/LinkMapping.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Poppler/Structs/LinkMapping.hs-boot @@ -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 diff --git a/GI/Poppler/Structs/PageTransition.hs b/GI/Poppler/Structs/PageTransition.hs new file mode 100644 --- /dev/null +++ b/GI/Poppler/Structs/PageTransition.hs @@ -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 () + + diff --git a/GI/Poppler/Structs/PageTransition.hs-boot b/GI/Poppler/Structs/PageTransition.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Poppler/Structs/PageTransition.hs-boot @@ -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 diff --git a/GI/Poppler/Structs/Point.hs b/GI/Poppler/Structs/Point.hs new file mode 100644 --- /dev/null +++ b/GI/Poppler/Structs/Point.hs @@ -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 () + + diff --git a/GI/Poppler/Structs/Point.hs-boot b/GI/Poppler/Structs/Point.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Poppler/Structs/Point.hs-boot @@ -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 diff --git a/GI/Poppler/Structs/Quadrilateral.hs b/GI/Poppler/Structs/Quadrilateral.hs new file mode 100644 --- /dev/null +++ b/GI/Poppler/Structs/Quadrilateral.hs @@ -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 () + + diff --git a/GI/Poppler/Structs/Quadrilateral.hs-boot b/GI/Poppler/Structs/Quadrilateral.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Poppler/Structs/Quadrilateral.hs-boot @@ -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 diff --git a/GI/Poppler/Structs/Rectangle.hs b/GI/Poppler/Structs/Rectangle.hs new file mode 100644 --- /dev/null +++ b/GI/Poppler/Structs/Rectangle.hs @@ -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 () + + diff --git a/GI/Poppler/Structs/Rectangle.hs-boot b/GI/Poppler/Structs/Rectangle.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Poppler/Structs/Rectangle.hs-boot @@ -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 diff --git a/GI/Poppler/Structs/StructureElementIter.hs b/GI/Poppler/Structs/StructureElementIter.hs new file mode 100644 --- /dev/null +++ b/GI/Poppler/Structs/StructureElementIter.hs @@ -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' + + diff --git a/GI/Poppler/Structs/StructureElementIter.hs-boot b/GI/Poppler/Structs/StructureElementIter.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Poppler/Structs/StructureElementIter.hs-boot @@ -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 diff --git a/GI/Poppler/Structs/TextAttributes.hs b/GI/Poppler/Structs/TextAttributes.hs new file mode 100644 --- /dev/null +++ b/GI/Poppler/Structs/TextAttributes.hs @@ -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 () + + diff --git a/GI/Poppler/Structs/TextAttributes.hs-boot b/GI/Poppler/Structs/TextAttributes.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Poppler/Structs/TextAttributes.hs-boot @@ -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 diff --git a/GI/Poppler/Structs/TextSpan.hs b/GI/Poppler/Structs/TextSpan.hs new file mode 100644 --- /dev/null +++ b/GI/Poppler/Structs/TextSpan.hs @@ -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' + + diff --git a/GI/Poppler/Structs/TextSpan.hs-boot b/GI/Poppler/Structs/TextSpan.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Poppler/Structs/TextSpan.hs-boot @@ -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 diff --git a/GI/Poppler/Types.hs b/GI/Poppler/Types.hs new file mode 100644 --- /dev/null +++ b/GI/Poppler/Types.hs @@ -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 + diff --git a/GI/Poppler/Unions.hs b/GI/Poppler/Unions.hs new file mode 100644 --- /dev/null +++ b/GI/Poppler/Unions.hs @@ -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 + + diff --git a/GI/Poppler/Unions/Action.hs b/GI/Poppler/Unions/Action.hs new file mode 100644 --- /dev/null +++ b/GI/Poppler/Unions/Action.hs @@ -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 () + + diff --git a/GI/Poppler/Unions/Action.hs-boot b/GI/Poppler/Unions/Action.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Poppler/Unions/Action.hs-boot @@ -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 diff --git a/LICENSE b/LICENSE new file mode 100644 --- /dev/null +++ b/LICENSE @@ -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. diff --git a/Setup.hs b/Setup.hs new file mode 100644 --- /dev/null +++ b/Setup.hs @@ -0,0 +1,3 @@ +#!/usr/bin/env runhaskell +import Distribution.Simple +main = defaultMain diff --git a/gi-poppler.cabal b/gi-poppler.cabal new file mode 100644 --- /dev/null +++ b/gi-poppler.cabal @@ -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