diff --git a/ChangeLog.md b/ChangeLog.md --- a/ChangeLog.md +++ b/ChangeLog.md @@ -1,3 +1,11 @@ +### 0.18.17 + ++ Update to haskell-gi(-base) 0.22 + +### 0.18.16 + ++ Update stack version to 12.10 + ### 0.18.15 + Remove enable-overloading flags, and use instead explicit CPP checks for 'haskell-gi-overloading-1.0', see [how to disable overloading](https://github.com/haskell-gi/haskell-gi/wiki/Overloading\#disabling-overloading). diff --git a/GI/Poppler.hs b/GI/Poppler.hs new file mode 100644 --- /dev/null +++ b/GI/Poppler.hs @@ -0,0 +1,60 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +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 , + + + + module Data.GI.Base , + + + ) 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 Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + + +import Data.GI.Base + 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,249 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Poppler.Callbacks + ( + + -- * Signals +-- ** AttachmentSaveFunc #signal:AttachmentSaveFunc# + + AttachmentSaveFunc , + AttachmentSaveFunc_WithClosures , + C_AttachmentSaveFunc , + drop_closures_AttachmentSaveFunc , + dynamic_AttachmentSaveFunc , + mk_AttachmentSaveFunc , + noAttachmentSaveFunc , + noAttachmentSaveFunc_WithClosures , + + +-- ** MediaSaveFunc #signal:MediaSaveFunc# + + C_MediaSaveFunc , + MediaSaveFunc , + MediaSaveFunc_WithClosures , + drop_closures_MediaSaveFunc , + dynamic_MediaSaveFunc , + mk_MediaSaveFunc , + noMediaSaveFunc , + noMediaSaveFunc_WithClosures , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + + +-- callback MediaSaveFunc +-- -> Callable {returnType = Just (TBasicType TBoolean), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Just "%TRUE if successful, %FALSE (with @error set) if failed.", sinceVersion = Nothing}, args = [Arg {argCName = "buf", argType = TCArray False (-1) 1 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "buffer containing\n bytes to be written.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "number of bytes in @buf.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data passed to poppler_media_save_to_callback()", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = True, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "Specifies the type of the function passed to\npoppler_media_save_to_callback(). It is called once for each block of\nbytes that is \"written\" by poppler_media_save_to_callback(). If\nsuccessful it should return %TRUE. If an error occurs it should set\n@error and return %FALSE, in which case poppler_media_save_to_callback()\nwill fail with the same error.", sinceVersion = Just "0.14"}} +-- | Type for the callback on the (unwrapped) C side. +type C_MediaSaveFunc = + Ptr Word8 -> + Word64 -> + Ptr () -> + Ptr (Ptr GError) -> + IO CInt + +-- Args : [Arg {argCName = "buf", argType = TCArray False (-1) 1 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "buffer containing\n bytes to be written.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "number of bytes in @buf.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data passed to poppler_media_save_to_callback()", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [Arg {argCName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "number of bytes in @buf.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "dynamic" __dynamic_C_MediaSaveFunc :: FunPtr C_MediaSaveFunc -> C_MediaSaveFunc + +-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell. +dynamic_MediaSaveFunc :: + (B.CallStack.HasCallStack, MonadIO m) => + FunPtr C_MediaSaveFunc + -> ByteString + {- ^ /@buf@/: buffer containing + bytes to be written. -} + -> Ptr () + {- ^ /@data@/: user data passed to 'GI.Poppler.Objects.Media.mediaSaveToCallback' -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +dynamic_MediaSaveFunc __funPtr buf data_ = liftIO $ do + let count = fromIntegral $ B.length buf + buf' <- packByteString buf + onException (do + _ <- propagateGError $ (__dynamic_C_MediaSaveFunc __funPtr) buf' count data_ + freeMem buf' + return () + ) (do + freeMem buf' + ) + +-- | Generate a function pointer callable from C code, from a `C_MediaSaveFunc`. +foreign import ccall "wrapper" + mk_MediaSaveFunc :: C_MediaSaveFunc -> IO (FunPtr C_MediaSaveFunc) + +{- | +Specifies the type of the function passed to +'GI.Poppler.Objects.Media.mediaSaveToCallback'. It is called once for each block of +bytes that is \"written\" by 'GI.Poppler.Objects.Media.mediaSaveToCallback'. If +successful it should return 'True'. If an error occurs it should set +/@error@/ and return 'False', in which case 'GI.Poppler.Objects.Media.mediaSaveToCallback' +will fail with the same error. + +/Since: 0.14/ +-} +type MediaSaveFunc = + ByteString + {- ^ /@buf@/: buffer containing + bytes to be written. -} + -> IO () + {- ^ __Returns:__ 'True' if successful, 'False' (with /@error@/ set) if failed. /(Can throw 'Data.GI.Base.GError.GError')/ -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `MediaSaveFunc`@. +noMediaSaveFunc :: Maybe MediaSaveFunc +noMediaSaveFunc = Nothing + +{- | +Specifies the type of the function passed to +'GI.Poppler.Objects.Media.mediaSaveToCallback'. It is called once for each block of +bytes that is \"written\" by 'GI.Poppler.Objects.Media.mediaSaveToCallback'. If +successful it should return 'True'. If an error occurs it should set +/@error@/ and return 'False', in which case 'GI.Poppler.Objects.Media.mediaSaveToCallback' +will fail with the same error. + +/Since: 0.14/ +-} +type MediaSaveFunc_WithClosures = + ByteString + {- ^ /@buf@/: buffer containing + bytes to be written. -} + -> Ptr () + {- ^ /@data@/: user data passed to 'GI.Poppler.Objects.Media.mediaSaveToCallback' -} + -> IO () + {- ^ __Returns:__ 'True' if successful, 'False' (with /@error@/ set) if failed. /(Can throw 'Data.GI.Base.GError.GError')/ -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `MediaSaveFunc_WithClosures`@. +noMediaSaveFunc_WithClosures :: Maybe MediaSaveFunc_WithClosures +noMediaSaveFunc_WithClosures = Nothing + +-- | A simple wrapper that ignores the closure arguments. +drop_closures_MediaSaveFunc :: MediaSaveFunc -> MediaSaveFunc_WithClosures +drop_closures_MediaSaveFunc _f buf _ = _f buf + +-- No Haskell->C wrapper generated since the function throws. + +-- callback AttachmentSaveFunc +-- -> Callable {returnType = Just (TBasicType TBoolean), returnMayBeNull = False, returnTransfer = TransferNothing, returnDocumentation = Documentation {rawDocText = Just "%TRUE if successful, %FALSE (with @error set) if failed.", sinceVersion = Nothing}, args = [Arg {argCName = "buf", argType = TCArray False (-1) 1 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "buffer containing\n bytes to be written.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "number of bytes in @buf.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data passed to poppler_attachment_save_to_callback()", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}], skipReturn = False, callableThrows = True, callableDeprecated = Nothing, callableDocumentation = Documentation {rawDocText = Just "Specifies the type of the function passed to\npoppler_attachment_save_to_callback(). It is called once for each block of\nbytes that is \"written\" by poppler_attachment_save_to_callback(). If\nsuccessful it should return %TRUE. If an error occurs it should set\n@error and return %FALSE, in which case poppler_attachment_save_to_callback()\nwill fail with the same error.", sinceVersion = Nothing}} +-- | Type for the callback on the (unwrapped) C side. +type C_AttachmentSaveFunc = + Ptr Word8 -> + Word64 -> + Ptr () -> + Ptr (Ptr GError) -> + IO CInt + +-- Args : [Arg {argCName = "buf", argType = TCArray False (-1) 1 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "buffer containing\n bytes to be written.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "number of bytes in @buf.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data passed to poppler_attachment_save_to_callback()", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [Arg {argCName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "number of bytes in @buf.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "dynamic" __dynamic_C_AttachmentSaveFunc :: FunPtr C_AttachmentSaveFunc -> C_AttachmentSaveFunc + +-- | Given a pointer to a foreign C function, wrap it into a function callable from Haskell. +dynamic_AttachmentSaveFunc :: + (B.CallStack.HasCallStack, MonadIO m) => + FunPtr C_AttachmentSaveFunc + -> ByteString + {- ^ /@buf@/: buffer containing + bytes to be written. -} + -> Ptr () + {- ^ /@data@/: user data passed to 'GI.Poppler.Objects.Attachment.attachmentSaveToCallback' -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +dynamic_AttachmentSaveFunc __funPtr buf data_ = liftIO $ do + let count = fromIntegral $ B.length buf + buf' <- packByteString buf + onException (do + _ <- propagateGError $ (__dynamic_C_AttachmentSaveFunc __funPtr) buf' count data_ + freeMem buf' + return () + ) (do + freeMem buf' + ) + +-- | Generate a function pointer callable from C code, from a `C_AttachmentSaveFunc`. +foreign import ccall "wrapper" + mk_AttachmentSaveFunc :: C_AttachmentSaveFunc -> IO (FunPtr C_AttachmentSaveFunc) + +{- | +Specifies the type of the function passed to +'GI.Poppler.Objects.Attachment.attachmentSaveToCallback'. It is called once for each block of +bytes that is \"written\" by 'GI.Poppler.Objects.Attachment.attachmentSaveToCallback'. If +successful it should return 'True'. If an error occurs it should set +/@error@/ and return 'False', in which case 'GI.Poppler.Objects.Attachment.attachmentSaveToCallback' +will fail with the same error. +-} +type AttachmentSaveFunc = + ByteString + {- ^ /@buf@/: buffer containing + bytes to be written. -} + -> IO () + {- ^ __Returns:__ 'True' if successful, 'False' (with /@error@/ set) if failed. /(Can throw 'Data.GI.Base.GError.GError')/ -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `AttachmentSaveFunc`@. +noAttachmentSaveFunc :: Maybe AttachmentSaveFunc +noAttachmentSaveFunc = Nothing + +{- | +Specifies the type of the function passed to +'GI.Poppler.Objects.Attachment.attachmentSaveToCallback'. It is called once for each block of +bytes that is \"written\" by 'GI.Poppler.Objects.Attachment.attachmentSaveToCallback'. If +successful it should return 'True'. If an error occurs it should set +/@error@/ and return 'False', in which case 'GI.Poppler.Objects.Attachment.attachmentSaveToCallback' +will fail with the same error. +-} +type AttachmentSaveFunc_WithClosures = + ByteString + {- ^ /@buf@/: buffer containing + bytes to be written. -} + -> Ptr () + {- ^ /@data@/: user data passed to 'GI.Poppler.Objects.Attachment.attachmentSaveToCallback' -} + -> IO () + {- ^ __Returns:__ 'True' if successful, 'False' (with /@error@/ set) if failed. /(Can throw 'Data.GI.Base.GError.GError')/ -} + +-- | A convenience synonym for @`Nothing` :: `Maybe` `AttachmentSaveFunc_WithClosures`@. +noAttachmentSaveFunc_WithClosures :: Maybe AttachmentSaveFunc_WithClosures +noAttachmentSaveFunc_WithClosures = Nothing + +-- | A simple wrapper that ignores the closure arguments. +drop_closures_AttachmentSaveFunc :: AttachmentSaveFunc -> AttachmentSaveFunc_WithClosures +drop_closures_AttachmentSaveFunc _f buf _ = _f buf + +-- No Haskell->C wrapper generated since the function throws. + + 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,126 @@ +{-# 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 (inaki@blueleaf.cc) +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +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 Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + + +{- | +The major version number of the poppler header files (e.g. in poppler version +0.1.2 this is 1.) + +/Since: 0.12/ +-} +pattern MINOR_VERSION = 73 :: Int32 + +{- | +The micro version number of the poppler header files (e.g. in poppler version +0.1.2 this is 2.) + +/Since: 0.12/ +-} +pattern MICRO_VERSION = 0 :: Int32 + +{- | +The major version number of the poppler header files (e.g. in poppler version +0.1.2 this is 0.) + +/Since: 0.12/ +-} +pattern MAJOR_VERSION = 0 :: Int32 + +{- | +Defined if poppler was compiled with cairo support. +-} +pattern HAS_CAIRO = 1 :: Int32 + +{- | +/No description available in the introspection data./ +-} +pattern ANNOT_TEXT_ICON_PARAGRAPH = "Paragraph" :: T.Text + +{- | +/No description available in the introspection data./ +-} +pattern ANNOT_TEXT_ICON_NOTE = "Note" :: T.Text + +{- | +/No description available in the introspection data./ +-} +pattern ANNOT_TEXT_ICON_NEW_PARAGRAPH = "NewParagraph" :: T.Text + +{- | +/No description available in the introspection data./ +-} +pattern ANNOT_TEXT_ICON_KEY = "Key" :: T.Text + +{- | +/No description available in the introspection data./ +-} +pattern ANNOT_TEXT_ICON_INSERT = "Insert" :: T.Text + +{- | +/No description available in the introspection data./ +-} +pattern ANNOT_TEXT_ICON_HELP = "Help" :: T.Text + +{- | +/No description available in the introspection data./ +-} +pattern ANNOT_TEXT_ICON_CROSS = "Cross" :: T.Text + +{- | +/No description available in the introspection data./ +-} +pattern ANNOT_TEXT_ICON_COMMENT = "Comment" :: T.Text + +{- | +/No description available in the introspection data./ +-} +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,3034 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Poppler.Enums + ( + + -- * Enumerations +-- ** ActionLayerAction #enum:ActionLayerAction# + + ActionLayerAction(..) , + + +-- ** ActionMovieOperation #enum:ActionMovieOperation# + + ActionMovieOperation(..) , + + +-- ** ActionType #enum:ActionType# + + ActionType(..) , + + +-- ** AdditionalActionType #enum:AdditionalActionType# + + AdditionalActionType(..) , + + +-- ** AnnotExternalDataType #enum:AnnotExternalDataType# + + AnnotExternalDataType(..) , + + +-- ** AnnotFreeTextQuadding #enum:AnnotFreeTextQuadding# + + AnnotFreeTextQuadding(..) , + + +-- ** AnnotMarkupReplyType #enum:AnnotMarkupReplyType# + + AnnotMarkupReplyType(..) , + + +-- ** AnnotTextState #enum:AnnotTextState# + + AnnotTextState(..) , + + +-- ** AnnotType #enum:AnnotType# + + AnnotType(..) , + + +-- ** Backend #enum:Backend# + + Backend(..) , + + +-- ** DestType #enum:DestType# + + DestType(..) , + + +-- ** Error #enum:Error# + + Error(..) , + catchError , + handleError , + + +-- ** FontType #enum:FontType# + + FontType(..) , + + +-- ** FormButtonType #enum:FormButtonType# + + FormButtonType(..) , + + +-- ** FormChoiceType #enum:FormChoiceType# + + FormChoiceType(..) , + + +-- ** FormFieldType #enum:FormFieldType# + + FormFieldType(..) , + + +-- ** FormTextType #enum:FormTextType# + + FormTextType(..) , + + +-- ** MoviePlayMode #enum:MoviePlayMode# + + MoviePlayMode(..) , + + +-- ** PDFConformance #enum:PDFConformance# + + PDFConformance(..) , + + +-- ** PDFPart #enum:PDFPart# + + PDFPart(..) , + + +-- ** PDFSubtype #enum:PDFSubtype# + + PDFSubtype(..) , + + +-- ** PageLayout #enum:PageLayout# + + PageLayout(..) , + + +-- ** PageMode #enum:PageMode# + + PageMode(..) , + + +-- ** PageTransitionAlignment #enum:PageTransitionAlignment# + + PageTransitionAlignment(..) , + + +-- ** PageTransitionDirection #enum:PageTransitionDirection# + + PageTransitionDirection(..) , + + +-- ** PageTransitionType #enum:PageTransitionType# + + PageTransitionType(..) , + + +-- ** PrintScaling #enum:PrintScaling# + + PrintScaling(..) , + + +-- ** SelectionStyle #enum:SelectionStyle# + + SelectionStyle(..) , + + +-- ** StructureBlockAlign #enum:StructureBlockAlign# + + StructureBlockAlign(..) , + + +-- ** StructureBorderStyle #enum:StructureBorderStyle# + + StructureBorderStyle(..) , + + +-- ** StructureElementKind #enum:StructureElementKind# + + StructureElementKind(..) , + + +-- ** StructureFormRole #enum:StructureFormRole# + + StructureFormRole(..) , + + +-- ** StructureFormState #enum:StructureFormState# + + StructureFormState(..) , + + +-- ** StructureGlyphOrientation #enum:StructureGlyphOrientation# + + StructureGlyphOrientation(..) , + + +-- ** StructureInlineAlign #enum:StructureInlineAlign# + + StructureInlineAlign(..) , + + +-- ** StructureListNumbering #enum:StructureListNumbering# + + StructureListNumbering(..) , + + +-- ** StructurePlacement #enum:StructurePlacement# + + StructurePlacement(..) , + + +-- ** StructureRubyAlign #enum:StructureRubyAlign# + + StructureRubyAlign(..) , + + +-- ** StructureRubyPosition #enum:StructureRubyPosition# + + StructureRubyPosition(..) , + + +-- ** StructureTableScope #enum:StructureTableScope# + + StructureTableScope(..) , + + +-- ** StructureTextAlign #enum:StructureTextAlign# + + StructureTextAlign(..) , + + +-- ** StructureTextDecoration #enum:StructureTextDecoration# + + StructureTextDecoration(..) , + + +-- ** StructureWritingMode #enum:StructureWritingMode# + + StructureWritingMode(..) , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + + +-- Enum StructureWritingMode +{- | +/No description available in the introspection data./ +-} +data StructureWritingMode = + StructureWritingModeLrTb + {- ^ + /No description available in the introspection data./ + -} + | StructureWritingModeRlTb + {- ^ + /No description available in the introspection data./ + -} + | StructureWritingModeTbRl + {- ^ + /No description available in the introspection data./ + -} + | AnotherStructureWritingMode Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.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 + +instance P.Ord StructureWritingMode where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +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 +{- | +/No description available in the introspection data./ +-} +data StructureTextDecoration = + StructureTextDecorationNone + {- ^ + /No description available in the introspection data./ + -} + | StructureTextDecorationUnderline + {- ^ + /No description available in the introspection data./ + -} + | StructureTextDecorationOverline + {- ^ + /No description available in the introspection data./ + -} + | StructureTextDecorationLinethrough + {- ^ + /No description available in the introspection data./ + -} + | AnotherStructureTextDecoration Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.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 + +instance P.Ord StructureTextDecoration where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +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 +{- | +/No description available in the introspection data./ +-} +data StructureTextAlign = + StructureTextAlignStart + {- ^ + /No description available in the introspection data./ + -} + | StructureTextAlignCenter + {- ^ + /No description available in the introspection data./ + -} + | StructureTextAlignEnd + {- ^ + /No description available in the introspection data./ + -} + | StructureTextAlignJustify + {- ^ + /No description available in the introspection data./ + -} + | AnotherStructureTextAlign Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.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 + +instance P.Ord StructureTextAlign where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +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 +{- | +/No description available in the introspection data./ +-} +data StructureTableScope = + StructureTableScopeRow + {- ^ + /No description available in the introspection data./ + -} + | StructureTableScopeColumn + {- ^ + /No description available in the introspection data./ + -} + | StructureTableScopeBoth + {- ^ + /No description available in the introspection data./ + -} + | AnotherStructureTableScope Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.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 + +instance P.Ord StructureTableScope where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +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 +{- | +/No description available in the introspection data./ +-} +data StructureRubyPosition = + StructureRubyPositionBefore + {- ^ + /No description available in the introspection data./ + -} + | StructureRubyPositionAfter + {- ^ + /No description available in the introspection data./ + -} + | StructureRubyPositionWarichu + {- ^ + /No description available in the introspection data./ + -} + | StructureRubyPositionInline + {- ^ + /No description available in the introspection data./ + -} + | AnotherStructureRubyPosition Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.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 + +instance P.Ord StructureRubyPosition where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +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 +{- | +/No description available in the introspection data./ +-} +data StructureRubyAlign = + StructureRubyAlignStart + {- ^ + /No description available in the introspection data./ + -} + | StructureRubyAlignCenter + {- ^ + /No description available in the introspection data./ + -} + | StructureRubyAlignEnd + {- ^ + /No description available in the introspection data./ + -} + | StructureRubyAlignJustify + {- ^ + /No description available in the introspection data./ + -} + | StructureRubyAlignDistribute + {- ^ + /No description available in the introspection data./ + -} + | AnotherStructureRubyAlign Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.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 + +instance P.Ord StructureRubyAlign where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +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 +{- | +/No description available in the introspection data./ +-} +data StructurePlacement = + StructurePlacementBlock + {- ^ + /No description available in the introspection data./ + -} + | StructurePlacementInline + {- ^ + /No description available in the introspection data./ + -} + | StructurePlacementBefore + {- ^ + /No description available in the introspection data./ + -} + | StructurePlacementStart + {- ^ + /No description available in the introspection data./ + -} + | StructurePlacementEnd + {- ^ + /No description available in the introspection data./ + -} + | AnotherStructurePlacement Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.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 + +instance P.Ord StructurePlacement where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +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 +{- | +/No description available in the introspection data./ +-} +data StructureListNumbering = + StructureListNumberingNone + {- ^ + /No description available in the introspection data./ + -} + | StructureListNumberingDisc + {- ^ + /No description available in the introspection data./ + -} + | StructureListNumberingCircle + {- ^ + /No description available in the introspection data./ + -} + | StructureListNumberingSquare + {- ^ + /No description available in the introspection data./ + -} + | StructureListNumberingDecimal + {- ^ + /No description available in the introspection data./ + -} + | StructureListNumberingUpperRoman + {- ^ + /No description available in the introspection data./ + -} + | StructureListNumberingLowerRoman + {- ^ + /No description available in the introspection data./ + -} + | StructureListNumberingUpperAlpha + {- ^ + /No description available in the introspection data./ + -} + | StructureListNumberingLowerAlpha + {- ^ + /No description available in the introspection data./ + -} + | AnotherStructureListNumbering Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.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 + +instance P.Ord StructureListNumbering where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +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 +{- | +/No description available in the introspection data./ +-} +data StructureInlineAlign = + StructureInlineAlignStart + {- ^ + /No description available in the introspection data./ + -} + | StructureInlineAlignCenter + {- ^ + /No description available in the introspection data./ + -} + | StructureInlineAlignEnd + {- ^ + /No description available in the introspection data./ + -} + | AnotherStructureInlineAlign Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.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 + +instance P.Ord StructureInlineAlign where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +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 +{- | +/No description available in the introspection data./ +-} +data StructureGlyphOrientation = + StructureGlyphOrientationAuto + {- ^ + /No description available in the introspection data./ + -} + | StructureGlyphOrientation0 + {- ^ + /No description available in the introspection data./ + -} + | StructureGlyphOrientation90 + {- ^ + /No description available in the introspection data./ + -} + | StructureGlyphOrientation180 + {- ^ + /No description available in the introspection data./ + -} + | StructureGlyphOrientation270 + {- ^ + /No description available in the introspection data./ + -} + | AnotherStructureGlyphOrientation Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.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 0 = StructureGlyphOrientation0 + toEnum 1 = StructureGlyphOrientation90 + toEnum 2 = StructureGlyphOrientation180 + toEnum 3 = StructureGlyphOrientation270 + toEnum k = AnotherStructureGlyphOrientation k + +instance P.Ord StructureGlyphOrientation where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +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 +{- | +/No description available in the introspection data./ +-} +data StructureFormState = + StructureFormStateOn + {- ^ + /No description available in the introspection data./ + -} + | StructureFormStateOff + {- ^ + /No description available in the introspection data./ + -} + | StructureFormStateNeutral + {- ^ + /No description available in the introspection data./ + -} + | AnotherStructureFormState Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.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 + +instance P.Ord StructureFormState where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +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 +{- | +/No description available in the introspection data./ +-} +data StructureFormRole = + StructureFormRoleUndefined + {- ^ + /No description available in the introspection data./ + -} + | StructureFormRoleRadioButton + {- ^ + /No description available in the introspection data./ + -} + | StructureFormRolePushButton + {- ^ + /No description available in the introspection data./ + -} + | StructureFormRoleTextValue + {- ^ + /No description available in the introspection data./ + -} + | StructureFormRoleCheckbox + {- ^ + /No description available in the introspection data./ + -} + | AnotherStructureFormRole Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.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 + +instance P.Ord StructureFormRole where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +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 +{- | +/No description available in the introspection data./ +-} +data StructureElementKind = + StructureElementKindContent + {- ^ + /No description available in the introspection data./ + -} + | StructureElementKindObjectReference + {- ^ + /No description available in the introspection data./ + -} + | StructureElementKindDocument + {- ^ + /No description available in the introspection data./ + -} + | StructureElementKindPart + {- ^ + /No description available in the introspection data./ + -} + | StructureElementKindArticle + {- ^ + /No description available in the introspection data./ + -} + | StructureElementKindSection + {- ^ + /No description available in the introspection data./ + -} + | StructureElementKindDiv + {- ^ + /No description available in the introspection data./ + -} + | StructureElementKindSpan + {- ^ + /No description available in the introspection data./ + -} + | StructureElementKindQuote + {- ^ + /No description available in the introspection data./ + -} + | StructureElementKindNote + {- ^ + /No description available in the introspection data./ + -} + | StructureElementKindReference + {- ^ + /No description available in the introspection data./ + -} + | StructureElementKindBibentry + {- ^ + /No description available in the introspection data./ + -} + | StructureElementKindCode + {- ^ + /No description available in the introspection data./ + -} + | StructureElementKindLink + {- ^ + /No description available in the introspection data./ + -} + | StructureElementKindAnnot + {- ^ + /No description available in the introspection data./ + -} + | StructureElementKindBlockquote + {- ^ + /No description available in the introspection data./ + -} + | StructureElementKindCaption + {- ^ + /No description available in the introspection data./ + -} + | StructureElementKindNonstruct + {- ^ + /No description available in the introspection data./ + -} + | StructureElementKindToc + {- ^ + /No description available in the introspection data./ + -} + | StructureElementKindTocItem + {- ^ + /No description available in the introspection data./ + -} + | StructureElementKindIndex + {- ^ + /No description available in the introspection data./ + -} + | StructureElementKindPrivate + {- ^ + /No description available in the introspection data./ + -} + | StructureElementKindParagraph + {- ^ + /No description available in the introspection data./ + -} + | StructureElementKindHeading + {- ^ + /No description available in the introspection data./ + -} + | StructureElementKindHeading1 + {- ^ + /No description available in the introspection data./ + -} + | StructureElementKindHeading2 + {- ^ + /No description available in the introspection data./ + -} + | StructureElementKindHeading3 + {- ^ + /No description available in the introspection data./ + -} + | StructureElementKindHeading4 + {- ^ + /No description available in the introspection data./ + -} + | StructureElementKindHeading5 + {- ^ + /No description available in the introspection data./ + -} + | StructureElementKindHeading6 + {- ^ + /No description available in the introspection data./ + -} + | StructureElementKindList + {- ^ + /No description available in the introspection data./ + -} + | StructureElementKindListItem + {- ^ + /No description available in the introspection data./ + -} + | StructureElementKindListLabel + {- ^ + /No description available in the introspection data./ + -} + | StructureElementKindListBody + {- ^ + /No description available in the introspection data./ + -} + | StructureElementKindTable + {- ^ + /No description available in the introspection data./ + -} + | StructureElementKindTableRow + {- ^ + /No description available in the introspection data./ + -} + | StructureElementKindTableHeading + {- ^ + /No description available in the introspection data./ + -} + | StructureElementKindTableData + {- ^ + /No description available in the introspection data./ + -} + | StructureElementKindTableHeader + {- ^ + /No description available in the introspection data./ + -} + | StructureElementKindTableFooter + {- ^ + /No description available in the introspection data./ + -} + | StructureElementKindTableBody + {- ^ + /No description available in the introspection data./ + -} + | StructureElementKindRuby + {- ^ + /No description available in the introspection data./ + -} + | StructureElementKindRubyBaseText + {- ^ + /No description available in the introspection data./ + -} + | StructureElementKindRubyAnnotText + {- ^ + /No description available in the introspection data./ + -} + | StructureElementKindRubyPunctuation + {- ^ + /No description available in the introspection data./ + -} + | StructureElementKindWarichu + {- ^ + /No description available in the introspection data./ + -} + | StructureElementKindWarichuText + {- ^ + /No description available in the introspection data./ + -} + | StructureElementKindWarichuPunctuation + {- ^ + /No description available in the introspection data./ + -} + | StructureElementKindFigure + {- ^ + /No description available in the introspection data./ + -} + | StructureElementKindFormula + {- ^ + /No description available in the introspection data./ + -} + | StructureElementKindForm + {- ^ + /No description available in the introspection data./ + -} + | AnotherStructureElementKind Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.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 + +instance P.Ord StructureElementKind where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +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 +{- | +/No description available in the introspection data./ +-} +data StructureBorderStyle = + StructureBorderStyleNone + {- ^ + /No description available in the introspection data./ + -} + | StructureBorderStyleHidden + {- ^ + /No description available in the introspection data./ + -} + | StructureBorderStyleDotted + {- ^ + /No description available in the introspection data./ + -} + | StructureBorderStyleDashed + {- ^ + /No description available in the introspection data./ + -} + | StructureBorderStyleSolid + {- ^ + /No description available in the introspection data./ + -} + | StructureBorderStyleDouble + {- ^ + /No description available in the introspection data./ + -} + | StructureBorderStyleGroove + {- ^ + /No description available in the introspection data./ + -} + | StructureBorderStyleInset + {- ^ + /No description available in the introspection data./ + -} + | StructureBorderStyleOutset + {- ^ + /No description available in the introspection data./ + -} + | AnotherStructureBorderStyle Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.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 + +instance P.Ord StructureBorderStyle where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +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 +{- | +/No description available in the introspection data./ +-} +data StructureBlockAlign = + StructureBlockAlignBefore + {- ^ + /No description available in the introspection data./ + -} + | StructureBlockAlignMiddle + {- ^ + /No description available in the introspection data./ + -} + | StructureBlockAlignAfter + {- ^ + /No description available in the introspection data./ + -} + | StructureBlockAlignJustify + {- ^ + /No description available in the introspection data./ + -} + | AnotherStructureBlockAlign Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.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 + +instance P.Ord StructureBlockAlign where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +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 +{- | +Selection styles +-} +data SelectionStyle = + SelectionStyleGlyph + {- ^ + glyph is the minimum unit for selection + -} + | SelectionStyleWord + {- ^ + word is the minimum unit for selection + -} + | SelectionStyleLine + {- ^ + line is the minimum unit for selection + -} + | AnotherSelectionStyle Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.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 + +instance P.Ord SelectionStyle where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +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 PrintScaling +{- | +PrintScaling viewer preference + +/Since: 0.73/ +-} +data PrintScaling = + PrintScalingAppDefault + {- ^ + application\'s default page scaling + -} + | PrintScalingNone + {- ^ + no page scaling + -} + | AnotherPrintScaling Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum PrintScaling where + fromEnum PrintScalingAppDefault = 0 + fromEnum PrintScalingNone = 1 + fromEnum (AnotherPrintScaling k) = k + + toEnum 0 = PrintScalingAppDefault + toEnum 1 = PrintScalingNone + toEnum k = AnotherPrintScaling k + +instance P.Ord PrintScaling where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "poppler_print_scaling_get_type" c_poppler_print_scaling_get_type :: + IO GType + +instance BoxedEnum PrintScaling where + boxedEnumType _ = c_poppler_print_scaling_get_type + +-- Enum PageTransitionType +{- | +Page transition types +-} +data PageTransitionType = + PageTransitionTypeReplace + {- ^ + the new page replace the old one + -} + | PageTransitionTypeSplit + {- ^ + two lines sweep across the screen, revealing the new page + -} + | PageTransitionTypeBlinds + {- ^ + multiple lines, evenly spaced across the screen, synchronously + sweep in the same direction to reveal the new page + -} + | PageTransitionTypeBox + {- ^ + a rectangular box sweeps inward from the edges of the page or + outward from the center revealing the new page + -} + | PageTransitionTypeWipe + {- ^ + a single line sweeps across the screen from one edge to the other + revealing the new page + -} + | PageTransitionTypeDissolve + {- ^ + the old page dissolves gradually to reveal the new one + -} + | PageTransitionTypeGlitter + {- ^ + similar to @/POPPLER_PAGE_TRANSITION_DISSOLVE/@, except that the effect + sweeps across the page in a wide band moving from one side of the screen to the other + -} + | PageTransitionTypeFly + {- ^ + changes are flown out or in to or from a location that is offscreen + -} + | PageTransitionTypePush + {- ^ + the old page slides off the screen while the new page slides in + -} + | PageTransitionTypeCover + {- ^ + the new page slides on to the screen covering the old page + -} + | PageTransitionTypeUncover + {- ^ + the old page slides off the screen uncovering the new page + -} + | PageTransitionTypeFade + {- ^ + the new page gradually becomes visible through the old one + -} + | AnotherPageTransitionType Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.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 + +instance P.Ord PageTransitionType where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +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 +{- | +Page transition direction types for @/POPPLER_PAGE_TRANSITION_SPLIT/@, +@/POPPLER_PAGE_TRANSITION_BOX/@ and @/POPPLER_PAGE_TRANSITION_FLY/@ transition types +-} +data PageTransitionDirection = + PageTransitionDirectionInward + {- ^ + inward from the edges of the page + -} + | PageTransitionDirectionOutward + {- ^ + outward from the center of the page + -} + | AnotherPageTransitionDirection Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum PageTransitionDirection where + fromEnum PageTransitionDirectionInward = 0 + fromEnum PageTransitionDirectionOutward = 1 + fromEnum (AnotherPageTransitionDirection k) = k + + toEnum 0 = PageTransitionDirectionInward + toEnum 1 = PageTransitionDirectionOutward + toEnum k = AnotherPageTransitionDirection k + +instance P.Ord PageTransitionDirection where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +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 +{- | +Page transition alignment types for @/POPPLER_PAGE_TRANSITION_SPLIT/@ +and @/POPPLER_PAGE_TRANSITION_BLINDS/@ transition types +-} +data PageTransitionAlignment = + PageTransitionAlignmentHorizontal + {- ^ + horizontal dimension + -} + | PageTransitionAlignmentVertical + {- ^ + vertical dimension + -} + | AnotherPageTransitionAlignment Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum PageTransitionAlignment where + fromEnum PageTransitionAlignmentHorizontal = 0 + fromEnum PageTransitionAlignmentVertical = 1 + fromEnum (AnotherPageTransitionAlignment k) = k + + toEnum 0 = PageTransitionAlignmentHorizontal + toEnum 1 = PageTransitionAlignmentVertical + toEnum k = AnotherPageTransitionAlignment k + +instance P.Ord PageTransitionAlignment where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +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 +{- | +Page modes +-} +data PageMode = + PageModeUnset + {- ^ + no specific mode set + -} + | PageModeNone + {- ^ + neither document outline nor thumbnails visible + -} + | PageModeUseOutlines + {- ^ + document outline visible + -} + | PageModeUseThumbs + {- ^ + thumbnails visible + -} + | PageModeFullScreen + {- ^ + full-screen mode + -} + | PageModeUseOc + {- ^ + layers panel visible + -} + | PageModeUseAttachments + {- ^ + attachments panel visible + -} + | AnotherPageMode Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.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 + +instance P.Ord PageMode where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +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 +{- | +Page layout types +-} +data PageLayout = + PageLayoutUnset + {- ^ + no specific layout set + -} + | PageLayoutSinglePage + {- ^ + one page at a time + -} + | PageLayoutOneColumn + {- ^ + pages in one column + -} + | PageLayoutTwoColumnLeft + {- ^ + pages in two columns with odd numbered pages on the left + -} + | PageLayoutTwoColumnRight + {- ^ + pages in two columns with odd numbered pages on the right + -} + | PageLayoutTwoPageLeft + {- ^ + two pages at a time with odd numbered pages on the left + -} + | PageLayoutTwoPageRight + {- ^ + two pages at a time with odd numbered pages on the right + -} + | AnotherPageLayout Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.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 + +instance P.Ord PageLayout where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +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 PDFSubtype +{- | +PDF Subtype + +/Since: 0.70/ +-} +data PDFSubtype = + PDFSubtypeUnset + {- ^ + Null + -} + | PDFSubtypePdfA + {- ^ + ISO 19005 - Document management -- Electronic document file format for long-term preservation (PDF\/A) + -} + | PDFSubtypePdfE + {- ^ + ISO 24517 - Document management -- Engineering document format using PDF (PDF\/E) + -} + | PDFSubtypePdfUa + {- ^ + ISO 14289 - Document management applications -- Electronic document file format enhancement for accessibility (PDF\/UA) + -} + | PDFSubtypePdfVt + {- ^ + ISO 16612 - Graphic technology -- Variable data exchange (PDF\/VT) + -} + | PDFSubtypePdfX + {- ^ + ISO 15930 - Graphic technology -- Prepress digital data exchange (PDF\/X) + -} + | PDFSubtypeNone + {- ^ + Not compliant with the above standards + -} + | AnotherPDFSubtype Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum PDFSubtype where + fromEnum PDFSubtypeUnset = 0 + fromEnum PDFSubtypePdfA = 1 + fromEnum PDFSubtypePdfE = 2 + fromEnum PDFSubtypePdfUa = 3 + fromEnum PDFSubtypePdfVt = 4 + fromEnum PDFSubtypePdfX = 5 + fromEnum PDFSubtypeNone = 6 + fromEnum (AnotherPDFSubtype k) = k + + toEnum 0 = PDFSubtypeUnset + toEnum 1 = PDFSubtypePdfA + toEnum 2 = PDFSubtypePdfE + toEnum 3 = PDFSubtypePdfUa + toEnum 4 = PDFSubtypePdfVt + toEnum 5 = PDFSubtypePdfX + toEnum 6 = PDFSubtypeNone + toEnum k = AnotherPDFSubtype k + +instance P.Ord PDFSubtype where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "poppler_pdf_subtype_get_type" c_poppler_pdf_subtype_get_type :: + IO GType + +instance BoxedEnum PDFSubtype where + boxedEnumType _ = c_poppler_pdf_subtype_get_type + +-- Enum PDFPart +{- | +PDF Subtype Part + +/Since: 0.70/ +-} +data PDFPart = + PDFPartUnset + {- ^ + Null + -} + | PDFPart1 + {- ^ + 1 + -} + | PDFPart2 + {- ^ + 2 + -} + | PDFPart3 + {- ^ + 3 + -} + | PDFPart4 + {- ^ + 4 + -} + | PDFPart5 + {- ^ + 5 + -} + | PDFPart6 + {- ^ + 6 + -} + | PDFPart7 + {- ^ + 7 + -} + | PDFPart8 + {- ^ + 8 + -} + | PDFPartNone + {- ^ + No part available + -} + | AnotherPDFPart Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum PDFPart where + fromEnum PDFPartUnset = 0 + fromEnum PDFPart1 = 1 + fromEnum PDFPart2 = 2 + fromEnum PDFPart3 = 3 + fromEnum PDFPart4 = 4 + fromEnum PDFPart5 = 5 + fromEnum PDFPart6 = 6 + fromEnum PDFPart7 = 7 + fromEnum PDFPart8 = 8 + fromEnum PDFPartNone = 9 + fromEnum (AnotherPDFPart k) = k + + toEnum 0 = PDFPartUnset + toEnum 1 = PDFPart1 + toEnum 2 = PDFPart2 + toEnum 3 = PDFPart3 + toEnum 4 = PDFPart4 + toEnum 5 = PDFPart5 + toEnum 6 = PDFPart6 + toEnum 7 = PDFPart7 + toEnum 8 = PDFPart8 + toEnum 9 = PDFPartNone + toEnum k = AnotherPDFPart k + +instance P.Ord PDFPart where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "poppler_pdf_part_get_type" c_poppler_pdf_part_get_type :: + IO GType + +instance BoxedEnum PDFPart where + boxedEnumType _ = c_poppler_pdf_part_get_type + +-- Enum PDFConformance +{- | +PDF Subtype Conformance + +/Since: 0.70/ +-} +data PDFConformance = + PDFConformanceUnset + {- ^ + Null + -} + | PDFConformanceA + {- ^ + Level A (accessible) conformance (PDF\/A) + -} + | PDFConformanceB + {- ^ + Level B (basic) conformance (PDF\/A) + -} + | PDFConformanceG + {- ^ + Level G (external graphical content) (PDF\/X) + -} + | PDFConformanceN + {- ^ + Level N (external ICC Profile) (PDF\/X) + -} + | PDFConformanceP + {- ^ + Level P (ICC Profile) (PDF\/X) + -} + | PDFConformancePg + {- ^ + Level PG (conjunction of P and G) (PDF\/X) + -} + | PDFConformanceU + {- ^ + Level U (Unicode) conformance (PDF\/A) + -} + | PDFConformanceNone + {- ^ + No conformance level available + -} + | AnotherPDFConformance Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum PDFConformance where + fromEnum PDFConformanceUnset = 0 + fromEnum PDFConformanceA = 1 + fromEnum PDFConformanceB = 2 + fromEnum PDFConformanceG = 3 + fromEnum PDFConformanceN = 4 + fromEnum PDFConformanceP = 5 + fromEnum PDFConformancePg = 6 + fromEnum PDFConformanceU = 7 + fromEnum PDFConformanceNone = 8 + fromEnum (AnotherPDFConformance k) = k + + toEnum 0 = PDFConformanceUnset + toEnum 1 = PDFConformanceA + toEnum 2 = PDFConformanceB + toEnum 3 = PDFConformanceG + toEnum 4 = PDFConformanceN + toEnum 5 = PDFConformanceP + toEnum 6 = PDFConformancePg + toEnum 7 = PDFConformanceU + toEnum 8 = PDFConformanceNone + toEnum k = AnotherPDFConformance k + +instance P.Ord PDFConformance where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "poppler_pdf_conformance_get_type" c_poppler_pdf_conformance_get_type :: + IO GType + +instance BoxedEnum PDFConformance where + boxedEnumType _ = c_poppler_pdf_conformance_get_type + +-- Enum MoviePlayMode +{- | +Play mode enum values. + +/Since: 0.54/ +-} +data MoviePlayMode = + MoviePlayModeOnce + {- ^ + the movie should be played once and controls should be closed at the end. + -} + | MoviePlayModeOpen + {- ^ + the movie should be played once, but controls should be left open. + -} + | MoviePlayModeRepeat + {- ^ + the movie should be played in loop, until manually stopped. + -} + | MoviePlayModePalindrome + {- ^ + the movie should be played forward and backward, forward and backward, + and so forth, until manually stopped. + -} + | AnotherMoviePlayMode Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum MoviePlayMode where + fromEnum MoviePlayModeOnce = 0 + fromEnum MoviePlayModeOpen = 1 + fromEnum MoviePlayModeRepeat = 2 + fromEnum MoviePlayModePalindrome = 3 + fromEnum (AnotherMoviePlayMode k) = k + + toEnum 0 = MoviePlayModeOnce + toEnum 1 = MoviePlayModeOpen + toEnum 2 = MoviePlayModeRepeat + toEnum 3 = MoviePlayModePalindrome + toEnum k = AnotherMoviePlayMode k + +instance P.Ord MoviePlayMode where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "poppler_movie_play_mode_get_type" c_poppler_movie_play_mode_get_type :: + IO GType + +instance BoxedEnum MoviePlayMode where + boxedEnumType _ = c_poppler_movie_play_mode_get_type + +-- Enum FormTextType +{- | +/No description available in the introspection data./ +-} +data FormTextType = + FormTextTypeNormal + {- ^ + /No description available in the introspection data./ + -} + | FormTextTypeMultiline + {- ^ + /No description available in the introspection data./ + -} + | FormTextTypeFileSelect + {- ^ + /No description available in the introspection data./ + -} + | AnotherFormTextType Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.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 + +instance P.Ord FormTextType where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +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 +{- | +/No description available in the introspection data./ +-} +data FormFieldType = + FormFieldTypeUnknown + {- ^ + /No description available in the introspection data./ + -} + | FormFieldTypeButton + {- ^ + /No description available in the introspection data./ + -} + | FormFieldTypeText + {- ^ + /No description available in the introspection data./ + -} + | FormFieldTypeChoice + {- ^ + /No description available in the introspection data./ + -} + | FormFieldTypeSignature + {- ^ + /No description available in the introspection data./ + -} + | AnotherFormFieldType Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.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 + +instance P.Ord FormFieldType where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +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 +{- | +/No description available in the introspection data./ +-} +data FormChoiceType = + FormChoiceTypeCombo + {- ^ + /No description available in the introspection data./ + -} + | FormChoiceTypeList + {- ^ + /No description available in the introspection data./ + -} + | AnotherFormChoiceType Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum FormChoiceType where + fromEnum FormChoiceTypeCombo = 0 + fromEnum FormChoiceTypeList = 1 + fromEnum (AnotherFormChoiceType k) = k + + toEnum 0 = FormChoiceTypeCombo + toEnum 1 = FormChoiceTypeList + toEnum k = AnotherFormChoiceType k + +instance P.Ord FormChoiceType where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +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 +{- | +/No description available in the introspection data./ +-} +data FormButtonType = + FormButtonTypePush + {- ^ + /No description available in the introspection data./ + -} + | FormButtonTypeCheck + {- ^ + /No description available in the introspection data./ + -} + | FormButtonTypeRadio + {- ^ + /No description available in the introspection data./ + -} + | AnotherFormButtonType Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.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 + +instance P.Ord FormButtonType where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +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 +{- | +Font types +-} +data FontType = + FontTypeUnknown + {- ^ + unknown font type + -} + | FontTypeType1 + {- ^ + Type 1 font type + -} + | FontTypeType1c + {- ^ + Type 1 font type embedded in Compact Font Format (CFF) font program + -} + | FontTypeType1cot + {- ^ + Type 1 font type embedded in OpenType font program + -} + | FontTypeType3 + {- ^ + A font type that is defined with PDF graphics operators + -} + | FontTypeTruetype + {- ^ + TrueType font type + -} + | FontTypeTruetypeot + {- ^ + TrueType font type embedded in OpenType font program + -} + | FontTypeCidType0 + {- ^ + CIDFont type based on Type 1 font technology + -} + | FontTypeCidType0c + {- ^ + CIDFont type based on Type 1 font technology embedded in CFF font program + -} + | FontTypeCidType0cot + {- ^ + CIDFont type based on Type 1 font technology embedded in OpenType font program + -} + | FontTypeCidType2 + {- ^ + CIDFont type based on TrueType font technology + -} + | FontTypeCidType2ot + {- ^ + CIDFont type based on TrueType font technology embedded in OpenType font program + -} + | AnotherFontType Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.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 + +instance P.Ord FontType where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +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 +{- | +Error codes returned by 'GI.Poppler.Objects.Document.Document' +-} +data Error = + ErrorInvalid + {- ^ + Generic error when a document operation fails + -} + | ErrorEncrypted + {- ^ + Document is encrypted + -} + | ErrorOpenFile + {- ^ + File could not be opened for writing when saving document + -} + | ErrorBadCatalog + {- ^ + Failed to read the document catalog + -} + | ErrorDamaged + {- ^ + Document is damaged + -} + | AnotherError Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.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 P.Ord Error where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +instance GErrorClass Error where + gerrorClassDomain _ = "poppler-quark" + +-- | Catch exceptions of type `Error`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`. +catchError :: + IO a -> + (Error -> GErrorMessage -> IO a) -> + IO a +catchError = catchGErrorJustDomain + +-- | Handle exceptions of type `Error`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`. +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 +{- | +Destination types +-} +data DestType = + DestTypeUnknown + {- ^ + unknown destination + -} + | DestTypeXyz + {- ^ + go to page with coordinates (left, top) + positioned at the upper-left corner of the window and the contents of + the page magnified by the factor zoom + -} + | DestTypeFit + {- ^ + go to page with its contents magnified just + enough to fit the entire page within the window both horizontally and + vertically + -} + | DestTypeFith + {- ^ + go to page with the vertical coordinate top + positioned at the top edge of the window and the contents of the page + magnified just enough to fit the entire width of the page within the window + -} + | DestTypeFitv + {- ^ + go to page with the horizontal coordinate + left positioned at the left edge of the window and the contents of the + page magnified just enough to fit the entire height of the page within the window + -} + | DestTypeFitr + {- ^ + go to page with its contents magnified just + enough to fit the rectangle specified by the coordinates left, bottom, + right, and top entirely within the window both horizontally and vertically + -} + | DestTypeFitb + {- ^ + go to page with its contents magnified just enough to fit + its bounding box entirely within the window both horizontally and vertically + -} + | DestTypeFitbh + {- ^ + go to page with the vertical + coordinate top positioned at the top edge of the window and the + contents of the page magnified just enough to fit the entire width of its + bounding box within the window + -} + | DestTypeFitbv + {- ^ + go to page with the horizontal + coordinate left positioned at the left edge of the window and the + contents of the page magnified just enough to fit the entire height of its + bounding box within the window + -} + | DestTypeNamed + {- ^ + got to page specified by a name. See 'GI.Poppler.Objects.Document.documentFindDest' + -} + | AnotherDestType Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.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 + +instance P.Ord DestType where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +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 +{- | +Backend codes returned by 'GI.Poppler.Functions.getBackend'. +-} +data Backend = + BackendUnknown + {- ^ + Unknown backend + -} + | BackendSplash + {- ^ + Splash backend + -} + | BackendCairo + {- ^ + Cairo backend + -} + | AnotherBackend Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.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 + +instance P.Ord Backend where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +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 +{- | +/No description available in the introspection data./ +-} +data AnnotType = + AnnotTypeUnknown + {- ^ + /No description available in the introspection data./ + -} + | AnnotTypeText + {- ^ + /No description available in the introspection data./ + -} + | AnnotTypeLink + {- ^ + /No description available in the introspection data./ + -} + | AnnotTypeFreeText + {- ^ + /No description available in the introspection data./ + -} + | AnnotTypeLine + {- ^ + /No description available in the introspection data./ + -} + | AnnotTypeSquare + {- ^ + /No description available in the introspection data./ + -} + | AnnotTypeCircle + {- ^ + /No description available in the introspection data./ + -} + | AnnotTypePolygon + {- ^ + /No description available in the introspection data./ + -} + | AnnotTypePolyLine + {- ^ + /No description available in the introspection data./ + -} + | AnnotTypeHighlight + {- ^ + /No description available in the introspection data./ + -} + | AnnotTypeUnderline + {- ^ + /No description available in the introspection data./ + -} + | AnnotTypeSquiggly + {- ^ + /No description available in the introspection data./ + -} + | AnnotTypeStrikeOut + {- ^ + /No description available in the introspection data./ + -} + | AnnotTypeStamp + {- ^ + /No description available in the introspection data./ + -} + | AnnotTypeCaret + {- ^ + /No description available in the introspection data./ + -} + | AnnotTypeInk + {- ^ + /No description available in the introspection data./ + -} + | AnnotTypePopup + {- ^ + /No description available in the introspection data./ + -} + | AnnotTypeFileAttachment + {- ^ + /No description available in the introspection data./ + -} + | AnnotTypeSound + {- ^ + /No description available in the introspection data./ + -} + | AnnotTypeMovie + {- ^ + /No description available in the introspection data./ + -} + | AnnotTypeWidget + {- ^ + /No description available in the introspection data./ + -} + | AnnotTypeScreen + {- ^ + /No description available in the introspection data./ + -} + | AnnotTypePrinterMark + {- ^ + /No description available in the introspection data./ + -} + | AnnotTypeTrapNet + {- ^ + /No description available in the introspection data./ + -} + | AnnotTypeWatermark + {- ^ + /No description available in the introspection data./ + -} + | AnnotType3d + {- ^ + /No description available in the introspection data./ + -} + | AnotherAnnotType Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.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 + +instance P.Ord AnnotType where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +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 +{- | +/No description available in the introspection data./ +-} +data AnnotTextState = + AnnotTextStateMarked + {- ^ + /No description available in the introspection data./ + -} + | AnnotTextStateUnmarked + {- ^ + /No description available in the introspection data./ + -} + | AnnotTextStateAccepted + {- ^ + /No description available in the introspection data./ + -} + | AnnotTextStateRejected + {- ^ + /No description available in the introspection data./ + -} + | AnnotTextStateCancelled + {- ^ + /No description available in the introspection data./ + -} + | AnnotTextStateCompleted + {- ^ + /No description available in the introspection data./ + -} + | AnnotTextStateNone + {- ^ + /No description available in the introspection data./ + -} + | AnnotTextStateUnknown + {- ^ + /No description available in the introspection data./ + -} + | AnotherAnnotTextState Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.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 + +instance P.Ord AnnotTextState where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +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 +{- | +/No description available in the introspection data./ +-} +data AnnotMarkupReplyType = + AnnotMarkupReplyTypeR + {- ^ + /No description available in the introspection data./ + -} + | AnnotMarkupReplyTypeGroup + {- ^ + /No description available in the introspection data./ + -} + | AnotherAnnotMarkupReplyType Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum AnnotMarkupReplyType where + fromEnum AnnotMarkupReplyTypeR = 0 + fromEnum AnnotMarkupReplyTypeGroup = 1 + fromEnum (AnotherAnnotMarkupReplyType k) = k + + toEnum 0 = AnnotMarkupReplyTypeR + toEnum 1 = AnnotMarkupReplyTypeGroup + toEnum k = AnotherAnnotMarkupReplyType k + +instance P.Ord AnnotMarkupReplyType where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +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 +{- | +/No description available in the introspection data./ +-} +data AnnotFreeTextQuadding = + AnnotFreeTextQuaddingLeftJustified + {- ^ + /No description available in the introspection data./ + -} + | AnnotFreeTextQuaddingCentered + {- ^ + /No description available in the introspection data./ + -} + | AnnotFreeTextQuaddingRightJustified + {- ^ + /No description available in the introspection data./ + -} + | AnotherAnnotFreeTextQuadding Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.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 + +instance P.Ord AnnotFreeTextQuadding where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +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 +{- | +/No description available in the introspection data./ +-} +data AnnotExternalDataType = + AnnotExternalDataType3d + {- ^ + /No description available in the introspection data./ + -} + | AnnotExternalDataTypeUnknown + {- ^ + /No description available in the introspection data./ + -} + | AnotherAnnotExternalDataType Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum AnnotExternalDataType where + fromEnum AnnotExternalDataType3d = 0 + fromEnum AnnotExternalDataTypeUnknown = 1 + fromEnum (AnotherAnnotExternalDataType k) = k + + toEnum 0 = AnnotExternalDataType3d + toEnum 1 = AnnotExternalDataTypeUnknown + toEnum k = AnotherAnnotExternalDataType k + +instance P.Ord AnnotExternalDataType where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +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 AdditionalActionType +{- | +Form field additional action types to be passed to /@popplerFormFieldGetAdditionalAction@/ + +/Since: 0.72/ +-} +data AdditionalActionType = + AdditionalActionTypeFieldModified + {- ^ + The action to be performed when the user modifies the field. + -} + | AdditionalActionTypeFormatField + {- ^ + The action to be performed before the field is formatted to + display its value. + -} + | AdditionalActionTypeValidateField + {- ^ + The action to be performed when the field value changes. + -} + | AdditionalActionTypeCalculateField + {- ^ + The action to be performed when the field needs to be + recalculated. + -} + | AnotherAdditionalActionType Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum AdditionalActionType where + fromEnum AdditionalActionTypeFieldModified = 0 + fromEnum AdditionalActionTypeFormatField = 1 + fromEnum AdditionalActionTypeValidateField = 2 + fromEnum AdditionalActionTypeCalculateField = 3 + fromEnum (AnotherAdditionalActionType k) = k + + toEnum 0 = AdditionalActionTypeFieldModified + toEnum 1 = AdditionalActionTypeFormatField + toEnum 2 = AdditionalActionTypeValidateField + toEnum 3 = AdditionalActionTypeCalculateField + toEnum k = AnotherAdditionalActionType k + +instance P.Ord AdditionalActionType where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "poppler_additional_action_type_get_type" c_poppler_additional_action_type_get_type :: + IO GType + +instance BoxedEnum AdditionalActionType where + boxedEnumType _ = c_poppler_additional_action_type_get_type + +-- Enum ActionType +{- | +Action types +-} +data ActionType = + ActionTypeUnknown + {- ^ + unknown action + -} + | ActionTypeNone + {- ^ + no action specified + -} + | ActionTypeGotoDest + {- ^ + go to destination + -} + | ActionTypeGotoRemote + {- ^ + go to destination in another document + -} + | ActionTypeLaunch + {- ^ + launch app (or open document + -} + | ActionTypeUri + {- ^ + URI + -} + | ActionTypeNamed + {- ^ + predefined action + -} + | ActionTypeMovie + {- ^ + play movies. Since 0.14 + -} + | ActionTypeRendition + {- ^ + play multimedia content. Since 0.14 + -} + | ActionTypeOcgState + {- ^ + state of layer. Since 0.14 + -} + | ActionTypeJavascript + {- ^ + Javascript. Since 0.18 + -} + | AnotherActionType Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.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 + +instance P.Ord ActionType where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +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 +{- | +Movie operations + +/Since: 0.14/ +-} +data ActionMovieOperation = + ActionMovieOperationPlay + {- ^ + play movie + -} + | ActionMovieOperationPause + {- ^ + pause playing movie + -} + | ActionMovieOperationResume + {- ^ + resume paused movie + -} + | ActionMovieOperationStop + {- ^ + stop playing movie + -} + | AnotherActionMovieOperation Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.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 + +instance P.Ord ActionMovieOperation where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +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 +{- | +Layer actions + +/Since: 0.14/ +-} +data ActionLayerAction = + ActionLayerActionOn + {- ^ + set layer visibility on + -} + | ActionLayerActionOff + {- ^ + set layer visibility off + -} + | ActionLayerActionToggle + {- ^ + reverse the layer visibility state + -} + | AnotherActionLayerAction Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.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 + +instance P.Ord ActionLayerAction where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +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/Enums.hs-boot b/GI/Poppler/Enums.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Poppler/Enums.hs-boot @@ -0,0 +1,153 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Poppler.Enums where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +data StructureWritingMode +instance P.Enum StructureWritingMode where +instance BoxedEnum StructureWritingMode where +data StructureTextDecoration +instance P.Enum StructureTextDecoration where +instance BoxedEnum StructureTextDecoration where +data StructureTextAlign +instance P.Enum StructureTextAlign where +instance BoxedEnum StructureTextAlign where +data StructureTableScope +instance P.Enum StructureTableScope where +instance BoxedEnum StructureTableScope where +data StructureRubyPosition +instance P.Enum StructureRubyPosition where +instance BoxedEnum StructureRubyPosition where +data StructureRubyAlign +instance P.Enum StructureRubyAlign where +instance BoxedEnum StructureRubyAlign where +data StructurePlacement +instance P.Enum StructurePlacement where +instance BoxedEnum StructurePlacement where +data StructureListNumbering +instance P.Enum StructureListNumbering where +instance BoxedEnum StructureListNumbering where +data StructureInlineAlign +instance P.Enum StructureInlineAlign where +instance BoxedEnum StructureInlineAlign where +data StructureGlyphOrientation +instance P.Enum StructureGlyphOrientation where +instance BoxedEnum StructureGlyphOrientation where +data StructureFormState +instance P.Enum StructureFormState where +instance BoxedEnum StructureFormState where +data StructureFormRole +instance P.Enum StructureFormRole where +instance BoxedEnum StructureFormRole where +data StructureElementKind +instance P.Enum StructureElementKind where +instance BoxedEnum StructureElementKind where +data StructureBorderStyle +instance P.Enum StructureBorderStyle where +instance BoxedEnum StructureBorderStyle where +data StructureBlockAlign +instance P.Enum StructureBlockAlign where +instance BoxedEnum StructureBlockAlign where +data SelectionStyle +instance P.Enum SelectionStyle where +instance BoxedEnum SelectionStyle where +data PrintScaling +instance P.Enum PrintScaling where +instance BoxedEnum PrintScaling where +data PageTransitionType +instance P.Enum PageTransitionType where +instance BoxedEnum PageTransitionType where +data PageTransitionDirection +instance P.Enum PageTransitionDirection where +instance BoxedEnum PageTransitionDirection where +data PageTransitionAlignment +instance P.Enum PageTransitionAlignment where +instance BoxedEnum PageTransitionAlignment where +data PageMode +instance P.Enum PageMode where +instance BoxedEnum PageMode where +data PageLayout +instance P.Enum PageLayout where +instance BoxedEnum PageLayout where +data PDFSubtype +instance P.Enum PDFSubtype where +instance BoxedEnum PDFSubtype where +data PDFPart +instance P.Enum PDFPart where +instance BoxedEnum PDFPart where +data PDFConformance +instance P.Enum PDFConformance where +instance BoxedEnum PDFConformance where +data MoviePlayMode +instance P.Enum MoviePlayMode where +instance BoxedEnum MoviePlayMode where +data FormTextType +instance P.Enum FormTextType where +instance BoxedEnum FormTextType where +data FormFieldType +instance P.Enum FormFieldType where +instance BoxedEnum FormFieldType where +data FormChoiceType +instance P.Enum FormChoiceType where +instance BoxedEnum FormChoiceType where +data FormButtonType +instance P.Enum FormButtonType where +instance BoxedEnum FormButtonType where +data FontType +instance P.Enum FontType where +instance BoxedEnum FontType where +data Error +instance P.Enum Error where +instance BoxedEnum Error where +data DestType +instance P.Enum DestType where +instance BoxedEnum DestType where +data Backend +instance P.Enum Backend where +instance BoxedEnum Backend where +data AnnotType +instance P.Enum AnnotType where +instance BoxedEnum AnnotType where +data AnnotTextState +instance P.Enum AnnotTextState where +instance BoxedEnum AnnotTextState where +data AnnotMarkupReplyType +instance P.Enum AnnotMarkupReplyType where +instance BoxedEnum AnnotMarkupReplyType where +data AnnotFreeTextQuadding +instance P.Enum AnnotFreeTextQuadding where +instance BoxedEnum AnnotFreeTextQuadding where +data AnnotExternalDataType +instance P.Enum AnnotExternalDataType where +instance BoxedEnum AnnotExternalDataType where +data AdditionalActionType +instance P.Enum AdditionalActionType where +instance BoxedEnum AdditionalActionType where +data ActionType +instance P.Enum ActionType where +instance BoxedEnum ActionType where +data ActionMovieOperation +instance P.Enum ActionMovieOperation where +instance BoxedEnum ActionMovieOperation where +data ActionLayerAction +instance P.Enum ActionLayerAction where +instance BoxedEnum ActionLayerAction where 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,465 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Poppler.Flags + ( + + -- * Flags +-- ** AnnotFlag #flag:AnnotFlag# + + AnnotFlag(..) , + + +-- ** FindFlags #flag:FindFlags# + + FindFlags(..) , + + +-- ** Permissions #flag:Permissions# + + Permissions(..) , + + +-- ** PrintFlags #flag:PrintFlags# + + PrintFlags(..) , + + +-- ** StructureGetTextFlags #flag:StructureGetTextFlags# + + StructureGetTextFlags(..) , + + +-- ** ViewerPreferences #flag:ViewerPreferences# + + ViewerPreferences(..) , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + + +-- Flags ViewerPreferences +{- | +Viewer preferences +-} +data ViewerPreferences = + ViewerPreferencesUnset + {- ^ + no preferences set + -} + | ViewerPreferencesHideToolbar + {- ^ + hider toolbars when document is active + -} + | ViewerPreferencesHideMenubar + {- ^ + hide menu bar when document is active + -} + | ViewerPreferencesHideWindowui + {- ^ + hide UI elements in document\'s window + -} + | ViewerPreferencesFitWindow + {- ^ + resize document\'s window to fit the size of the first displayed page + -} + | ViewerPreferencesCenterWindow + {- ^ + position the document\'s window in the center of the screen + -} + | ViewerPreferencesDisplayDocTitle + {- ^ + display document title in window\'s title bar + -} + | ViewerPreferencesDirectionRtl + {- ^ + the predominant reading order for text is right to left + -} + | AnotherViewerPreferences Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.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 + +instance P.Ord ViewerPreferences where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "poppler_viewer_preferences_get_type" c_poppler_viewer_preferences_get_type :: + IO GType + +instance BoxedFlags ViewerPreferences where + boxedFlagsType _ = c_poppler_viewer_preferences_get_type + +instance IsGFlag ViewerPreferences + +-- Flags StructureGetTextFlags +{- | +/No description available in the introspection data./ +-} +data StructureGetTextFlags = + StructureGetTextFlagsNone + {- ^ + No flags. + -} + | StructureGetTextFlagsRecursive + {- ^ + For non-leaf, non-content + elements, recursively obtain the text from all the elements + enclosed in the subtree. + -} + | AnotherStructureGetTextFlags Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum StructureGetTextFlags where + fromEnum StructureGetTextFlagsNone = 0 + fromEnum StructureGetTextFlagsRecursive = 1 + fromEnum (AnotherStructureGetTextFlags k) = k + + toEnum 0 = StructureGetTextFlagsNone + toEnum 1 = StructureGetTextFlagsRecursive + toEnum k = AnotherStructureGetTextFlags k + +instance P.Ord StructureGetTextFlags where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "poppler_structure_get_text_flags_get_type" c_poppler_structure_get_text_flags_get_type :: + IO GType + +instance BoxedFlags StructureGetTextFlags where + boxedFlagsType _ = c_poppler_structure_get_text_flags_get_type + +instance IsGFlag StructureGetTextFlags + +-- Flags PrintFlags +{- | +Printing flags + +/Since: 0.16/ +-} +data PrintFlags = + PrintFlagsDocument + {- ^ + print main document contents + -} + | PrintFlagsMarkupAnnots + {- ^ + print document and markup annotations + -} + | PrintFlagsStampAnnotsOnly + {- ^ + print document and only stamp annotations + -} + | PrintFlagsAll + {- ^ + print main document contents and all markup annotations + -} + | AnotherPrintFlags Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.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 1 = PrintFlagsAll + toEnum k = AnotherPrintFlags k + +instance P.Ord PrintFlags where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "poppler_print_flags_get_type" c_poppler_print_flags_get_type :: + IO GType + +instance BoxedFlags PrintFlags where + boxedFlagsType _ = c_poppler_print_flags_get_type + +instance IsGFlag PrintFlags + +-- Flags Permissions +{- | +Permissions +-} +data Permissions = + PermissionsOkToPrint + {- ^ + document can be printer + -} + | PermissionsOkToModify + {- ^ + document contents can be modified + -} + | PermissionsOkToCopy + {- ^ + document can be copied + -} + | PermissionsOkToAddNotes + {- ^ + annotations can added to the document + -} + | PermissionsOkToFillForm + {- ^ + interactive form fields can be filled in + -} + | PermissionsOkToExtractContents + {- ^ + extract text and graphics + (in support of accessibility to users with disabilities or for other purposes). Since 0.18 + -} + | PermissionsOkToAssemble + {- ^ + assemble the document (insert, rotate, or delete pages and create + bookmarks or thumbnail images). Since 0.18 + -} + | PermissionsOkToPrintHighResolution + {- ^ + document can be printer at high resolution. Since 0.18 + -} + | PermissionsFull + {- ^ + document permits all operations + -} + | AnotherPermissions Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.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 + +instance P.Ord Permissions where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "poppler_permissions_get_type" c_poppler_permissions_get_type :: + IO GType + +instance BoxedFlags Permissions where + boxedFlagsType _ = c_poppler_permissions_get_type + +instance IsGFlag Permissions + +-- Flags FindFlags +{- | +Flags using while searching text in a page + +/Since: 0.22/ +-} +data FindFlags = + FindFlagsDefault + {- ^ + use default search settings + -} + | FindFlagsCaseSensitive + {- ^ + do case sensitive search + -} + | FindFlagsBackwards + {- ^ + search backwards + -} + | FindFlagsWholeWordsOnly + {- ^ + search only whole words + -} + | FindFlagsIgnoreDiacritics + {- ^ + do diacritics insensitive search, + i.e. ignore accents, umlauts, diaeresis,etc. while matching. This + option will be ignored if the search term is not pure ascii. Since 0.73. + -} + | AnotherFindFlags Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.Enum FindFlags where + fromEnum FindFlagsDefault = 0 + fromEnum FindFlagsCaseSensitive = 1 + fromEnum FindFlagsBackwards = 2 + fromEnum FindFlagsWholeWordsOnly = 4 + fromEnum FindFlagsIgnoreDiacritics = 8 + fromEnum (AnotherFindFlags k) = k + + toEnum 0 = FindFlagsDefault + toEnum 1 = FindFlagsCaseSensitive + toEnum 2 = FindFlagsBackwards + toEnum 4 = FindFlagsWholeWordsOnly + toEnum 8 = FindFlagsIgnoreDiacritics + toEnum k = AnotherFindFlags k + +instance P.Ord FindFlags where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "poppler_find_flags_get_type" c_poppler_find_flags_get_type :: + IO GType + +instance BoxedFlags FindFlags where + boxedFlagsType _ = c_poppler_find_flags_get_type + +instance IsGFlag FindFlags + +-- Flags AnnotFlag +{- | +/No description available in the introspection data./ +-} +data AnnotFlag = + AnnotFlagUnknown + {- ^ + /No description available in the introspection data./ + -} + | AnnotFlagInvisible + {- ^ + /No description available in the introspection data./ + -} + | AnnotFlagHidden + {- ^ + /No description available in the introspection data./ + -} + | AnnotFlagPrint + {- ^ + /No description available in the introspection data./ + -} + | AnnotFlagNoZoom + {- ^ + /No description available in the introspection data./ + -} + | AnnotFlagNoRotate + {- ^ + /No description available in the introspection data./ + -} + | AnnotFlagNoView + {- ^ + /No description available in the introspection data./ + -} + | AnnotFlagReadOnly + {- ^ + /No description available in the introspection data./ + -} + | AnnotFlagLocked + {- ^ + /No description available in the introspection data./ + -} + | AnnotFlagToggleNoView + {- ^ + /No description available in the introspection data./ + -} + | AnnotFlagLockedContents + {- ^ + /No description available in the introspection data./ + -} + | AnotherAnnotFlag Int + -- ^ Catch-all for unknown values + deriving (Show, Eq) + +instance P.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 + +instance P.Ord AnnotFlag where + compare a b = P.compare (P.fromEnum a) (P.fromEnum b) + +foreign import ccall "poppler_annot_flag_get_type" c_poppler_annot_flag_get_type :: + IO GType + +instance BoxedFlags AnnotFlag where + boxedFlagsType _ = c_poppler_annot_flag_get_type + +instance IsGFlag AnnotFlag + + diff --git a/GI/Poppler/Flags.hs-boot b/GI/Poppler/Flags.hs-boot new file mode 100644 --- /dev/null +++ b/GI/Poppler/Flags.hs-boot @@ -0,0 +1,48 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Poppler.Flags where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +data ViewerPreferences +instance P.Enum ViewerPreferences where +instance BoxedFlags ViewerPreferences where +instance IsGFlag ViewerPreferences +data StructureGetTextFlags +instance P.Enum StructureGetTextFlags where +instance BoxedFlags StructureGetTextFlags where +instance IsGFlag StructureGetTextFlags +data PrintFlags +instance P.Enum PrintFlags where +instance BoxedFlags PrintFlags where +instance IsGFlag PrintFlags +data Permissions +instance P.Enum Permissions where +instance BoxedFlags Permissions where +instance IsGFlag Permissions +data FindFlags +instance P.Enum FindFlags where +instance BoxedFlags FindFlags where +instance IsGFlag FindFlags +data AnnotFlag +instance P.Enum AnnotFlag where +instance BoxedFlags AnnotFlag where +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,234 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Poppler.Functions + ( + + -- * Methods +-- ** dateParse #method:dateParse# + + dateParse , + + +-- ** getBackend #method:getBackend# + + getBackend , + + +-- ** getVersion #method:getVersion# + + getVersion , + + +-- ** namedDestFromBytestring #method:namedDestFromBytestring# + + namedDestFromBytestring , + + +-- ** namedDestToBytestring #method:namedDestToBytestring# + + namedDestToBytestring , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import {-# SOURCE #-} qualified GI.Poppler.Enums as Poppler.Enums + +-- function poppler_named_dest_to_bytestring +-- Args : [Arg {argCName = "named_dest", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "length", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a location to store the length of the returned bytestring", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [Arg {argCName = "length", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a location to store the length of the returned bytestring", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- returnType : Just (TCArray False (-1) 1 (TBasicType TUInt8)) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_named_dest_to_bytestring" poppler_named_dest_to_bytestring :: + CString -> -- named_dest : TBasicType TUTF8 + Ptr Word64 -> -- length : TBasicType TUInt64 + IO (Ptr Word8) + +{- | +Converts a named dest string (e.g. from 'GI.Poppler.Structs.Dest.Dest'.@/named_dest/@) into a +bytestring, inverting the transformation of +'GI.Poppler.Functions.namedDestFromBytestring'. + +Note that the returned data is not zero terminated and may also +contains embedded NUL bytes. + +If /@name@/ is not a valid named dest string, returns 'Nothing'. + +The returned data must be freed using 'GI.GLib.Functions.free'. + +/Since: 0.73/ +-} +namedDestToBytestring :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + -> m (Maybe ByteString) + {- ^ __Returns:__ a new bytestring, + or 'Nothing' -} +namedDestToBytestring namedDest = liftIO $ do + namedDest' <- textToCString namedDest + length_ <- allocMem :: IO (Ptr Word64) + result <- poppler_named_dest_to_bytestring namedDest' length_ + length_' <- peek length_ + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (unpackByteStringWithLength length_') result' + freeMem result' + return result'' + freeMem namedDest' + freeMem length_ + return maybeResult + + +-- function poppler_named_dest_from_bytestring +-- Args : [Arg {argCName = "data", argType = TCArray False (-1) 1 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the bytestring data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "length", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the bytestring length", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [Arg {argCName = "length", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the bytestring length", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_named_dest_from_bytestring" poppler_named_dest_from_bytestring :: + Ptr Word8 -> -- data : TCArray False (-1) 1 (TBasicType TUInt8) + Word64 -> -- length : TBasicType TUInt64 + IO CString + +{- | +Converts a bytestring into a zero-terminated string suitable to +pass to 'GI.Poppler.Objects.Document.documentFindDest'. + +Note that the returned string has no defined encoding and is not +suitable for display to the user. + +The returned data must be freed using 'GI.GLib.Functions.free'. + +/Since: 0.73/ +-} +namedDestFromBytestring :: + (B.CallStack.HasCallStack, MonadIO m) => + ByteString + {- ^ /@data@/: the bytestring data -} + -> m T.Text + {- ^ __Returns:__ the named dest -} +namedDestFromBytestring data_ = liftIO $ do + let length_ = fromIntegral $ B.length data_ + data_' <- packByteString data_ + result <- poppler_named_dest_from_bytestring data_' length_ + checkUnexpectedReturnNULL "namedDestFromBytestring" result + result' <- cstringToText result + freeMem result + freeMem data_' + return result' + + +-- function poppler_get_version +-- Args : [] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_get_version" poppler_get_version :: + IO CString + +{- | +Returns the version of poppler in use. This result is not to be freed. +-} +getVersion :: + (B.CallStack.HasCallStack, MonadIO m) => + m T.Text + {- ^ __Returns:__ the version of poppler. -} +getVersion = liftIO $ do + result <- poppler_get_version + checkUnexpectedReturnNULL "getVersion" result + result' <- cstringToText result + return result' + + +-- function poppler_get_backend +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "Backend"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_get_backend" poppler_get_backend :: + IO CUInt + +{- | +Returns the backend compiled into the poppler library. +-} +getBackend :: + (B.CallStack.HasCallStack, MonadIO m) => + m Poppler.Enums.Backend + {- ^ __Returns:__ The backend used by poppler -} +getBackend = liftIO $ do + result <- poppler_get_backend + let result' = (toEnum . fromIntegral) result + return result' + + +-- function poppler_date_parse +-- Args : [Arg {argCName = "date", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "string to parse", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timet", argType = TBasicType TLong, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an uninitialized #time_t", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_date_parse" poppler_date_parse :: + CString -> -- date : TBasicType TUTF8 + CLong -> -- timet : TBasicType TLong + IO CInt + +{- | +Parses a PDF format date string and converts it to a @/time_t/@. Returns @/FALSE/@ +if the parsing fails or the input string is not a valid PDF format date string + +/Since: 0.12/ +-} +dateParse :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + {- ^ /@date@/: string to parse -} + -> CLong + {- ^ /@timet@/: an uninitialized @/time_t/@ -} + -> m Bool + {- ^ __Returns:__ @/TRUE/@, if /@timet@/ was set -} +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,81 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +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 Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + + + 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,701 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Poppler.Objects.Annot + ( + +-- * Exported types + Annot(..) , + IsAnnot , + toAnnot , + noAnnot , + + + -- * Methods +-- ** getAnnotType #method:getAnnotType# + +#if ENABLE_OVERLOADING + AnnotGetAnnotTypeMethodInfo , +#endif + annotGetAnnotType , + + +-- ** getColor #method:getColor# + +#if ENABLE_OVERLOADING + AnnotGetColorMethodInfo , +#endif + annotGetColor , + + +-- ** getContents #method:getContents# + +#if ENABLE_OVERLOADING + AnnotGetContentsMethodInfo , +#endif + annotGetContents , + + +-- ** getFlags #method:getFlags# + +#if ENABLE_OVERLOADING + AnnotGetFlagsMethodInfo , +#endif + annotGetFlags , + + +-- ** getModified #method:getModified# + +#if ENABLE_OVERLOADING + AnnotGetModifiedMethodInfo , +#endif + annotGetModified , + + +-- ** getName #method:getName# + +#if ENABLE_OVERLOADING + AnnotGetNameMethodInfo , +#endif + annotGetName , + + +-- ** getPageIndex #method:getPageIndex# + +#if ENABLE_OVERLOADING + AnnotGetPageIndexMethodInfo , +#endif + annotGetPageIndex , + + +-- ** getRectangle #method:getRectangle# + +#if ENABLE_OVERLOADING + AnnotGetRectangleMethodInfo , +#endif + annotGetRectangle , + + +-- ** setColor #method:setColor# + +#if ENABLE_OVERLOADING + AnnotSetColorMethodInfo , +#endif + annotSetColor , + + +-- ** setContents #method:setContents# + +#if ENABLE_OVERLOADING + AnnotSetContentsMethodInfo , +#endif + annotSetContents , + + +-- ** setFlags #method:setFlags# + +#if ENABLE_OVERLOADING + AnnotSetFlagsMethodInfo , +#endif + annotSetFlags , + + +-- ** setRectangle #method:setRectangle# + +#if ENABLE_OVERLOADING + AnnotSetRectangleMethodInfo , +#endif + annotSetRectangle , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import qualified GI.GObject.Objects.Object as GObject.Object +import {-# SOURCE #-} qualified GI.Poppler.Enums as Poppler.Enums +import {-# SOURCE #-} qualified GI.Poppler.Flags as Poppler.Flags +import {-# SOURCE #-} qualified GI.Poppler.Structs.Color as Poppler.Color +import {-# SOURCE #-} qualified GI.Poppler.Structs.Rectangle as Poppler.Rectangle + +-- | Memory-managed wrapper type. +newtype Annot = Annot (ManagedPtr Annot) +foreign import ccall "poppler_annot_get_type" + c_poppler_annot_get_type :: IO GType + +instance GObject Annot where + gobjectType = c_poppler_annot_get_type + + +-- | Type class for types which can be safely cast to `Annot`, for instance with `toAnnot`. +class (GObject o, O.IsDescendantOf Annot o) => IsAnnot o +instance (GObject o, O.IsDescendantOf Annot o) => IsAnnot o + +instance O.HasParentTypes Annot +type instance O.ParentTypes Annot = '[GObject.Object.Object] + +-- | Cast to `Annot`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toAnnot :: (MonadIO m, IsAnnot o) => o -> m Annot +toAnnot = liftIO . unsafeCastTo Annot + +-- | A convenience alias for `Nothing` :: `Maybe` `Annot`. +noAnnot :: Maybe Annot +noAnnot = Nothing + +#if ENABLE_OVERLOADING +type family ResolveAnnotMethod (t :: Symbol) (o :: *) :: * where + ResolveAnnotMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveAnnotMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveAnnotMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveAnnotMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveAnnotMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveAnnotMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveAnnotMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveAnnotMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveAnnotMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveAnnotMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveAnnotMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveAnnotMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveAnnotMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveAnnotMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveAnnotMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveAnnotMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveAnnotMethod "getAnnotType" o = AnnotGetAnnotTypeMethodInfo + ResolveAnnotMethod "getColor" o = AnnotGetColorMethodInfo + ResolveAnnotMethod "getContents" o = AnnotGetContentsMethodInfo + ResolveAnnotMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveAnnotMethod "getFlags" o = AnnotGetFlagsMethodInfo + ResolveAnnotMethod "getModified" o = AnnotGetModifiedMethodInfo + ResolveAnnotMethod "getName" o = AnnotGetNameMethodInfo + ResolveAnnotMethod "getPageIndex" o = AnnotGetPageIndexMethodInfo + ResolveAnnotMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveAnnotMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveAnnotMethod "getRectangle" o = AnnotGetRectangleMethodInfo + ResolveAnnotMethod "setColor" o = AnnotSetColorMethodInfo + ResolveAnnotMethod "setContents" o = AnnotSetContentsMethodInfo + ResolveAnnotMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveAnnotMethod "setFlags" o = AnnotSetFlagsMethodInfo + ResolveAnnotMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveAnnotMethod "setRectangle" o = AnnotSetRectangleMethodInfo + ResolveAnnotMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveAnnotMethod t Annot, O.MethodInfo info Annot p) => OL.IsLabel t (Annot -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList Annot +type instance O.AttributeList Annot = AnnotAttributeList +type AnnotAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList Annot = AnnotSignalList +type AnnotSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method Annot::get_annot_type +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_annot", argType = TInterface (Name {namespace = "Poppler", name = "Annot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerAnnot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "AnnotType"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_annot_get_annot_type" poppler_annot_get_annot_type :: + Ptr Annot -> -- poppler_annot : TInterface (Name {namespace = "Poppler", name = "Annot"}) + IO CUInt + +{- | +Gets the type of /@popplerAnnot@/ +-} +annotGetAnnotType :: + (B.CallStack.HasCallStack, MonadIO m, IsAnnot a) => + a + {- ^ /@popplerAnnot@/: a 'GI.Poppler.Objects.Annot.Annot' -} + -> m Poppler.Enums.AnnotType + {- ^ __Returns:__ 'GI.Poppler.Enums.AnnotType' of /@popplerAnnot@/. -} +annotGetAnnotType popplerAnnot = liftIO $ do + popplerAnnot' <- unsafeManagedPtrCastPtr popplerAnnot + result <- poppler_annot_get_annot_type popplerAnnot' + let result' = (toEnum . fromIntegral) result + touchManagedPtr popplerAnnot + return result' + +#if ENABLE_OVERLOADING +data AnnotGetAnnotTypeMethodInfo +instance (signature ~ (m Poppler.Enums.AnnotType), MonadIO m, IsAnnot a) => O.MethodInfo AnnotGetAnnotTypeMethodInfo a signature where + overloadedMethod _ = annotGetAnnotType + +#endif + +-- method Annot::get_color +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_annot", argType = TInterface (Name {namespace = "Poppler", name = "Annot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerAnnot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "Color"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_annot_get_color" poppler_annot_get_color :: + Ptr Annot -> -- poppler_annot : TInterface (Name {namespace = "Poppler", name = "Annot"}) + IO (Ptr Poppler.Color.Color) + +{- | +Retrieves the color of /@popplerAnnot@/. +-} +annotGetColor :: + (B.CallStack.HasCallStack, MonadIO m, IsAnnot a) => + a + {- ^ /@popplerAnnot@/: a 'GI.Poppler.Objects.Annot.Annot' -} + -> m Poppler.Color.Color + {- ^ __Returns:__ a new allocated 'GI.Poppler.Structs.Color.Color' with the color values of + /@popplerAnnot@/, or 'Nothing'. It must be freed with 'GI.GLib.Functions.free' when done. -} +annotGetColor popplerAnnot = liftIO $ do + popplerAnnot' <- unsafeManagedPtrCastPtr popplerAnnot + result <- poppler_annot_get_color popplerAnnot' + checkUnexpectedReturnNULL "annotGetColor" result + result' <- (wrapBoxed Poppler.Color.Color) result + touchManagedPtr popplerAnnot + return result' + +#if ENABLE_OVERLOADING +data AnnotGetColorMethodInfo +instance (signature ~ (m Poppler.Color.Color), MonadIO m, IsAnnot a) => O.MethodInfo AnnotGetColorMethodInfo a signature where + overloadedMethod _ = annotGetColor + +#endif + +-- method Annot::get_contents +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_annot", argType = TInterface (Name {namespace = "Poppler", name = "Annot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerAnnot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_annot_get_contents" poppler_annot_get_contents :: + Ptr Annot -> -- poppler_annot : TInterface (Name {namespace = "Poppler", name = "Annot"}) + IO CString + +{- | +Retrieves the contents of /@popplerAnnot@/. +-} +annotGetContents :: + (B.CallStack.HasCallStack, MonadIO m, IsAnnot a) => + a + {- ^ /@popplerAnnot@/: a 'GI.Poppler.Objects.Annot.Annot' -} + -> m T.Text + {- ^ __Returns:__ a new allocated string with the contents of /@popplerAnnot@/. It + must be freed with 'GI.GLib.Functions.free' when done. -} +annotGetContents popplerAnnot = liftIO $ do + popplerAnnot' <- unsafeManagedPtrCastPtr popplerAnnot + result <- poppler_annot_get_contents popplerAnnot' + checkUnexpectedReturnNULL "annotGetContents" result + result' <- cstringToText result + freeMem result + touchManagedPtr popplerAnnot + return result' + +#if ENABLE_OVERLOADING +data AnnotGetContentsMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsAnnot a) => O.MethodInfo AnnotGetContentsMethodInfo a signature where + overloadedMethod _ = annotGetContents + +#endif + +-- method Annot::get_flags +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_annot", argType = TInterface (Name {namespace = "Poppler", name = "Annot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerAnnot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "AnnotFlag"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_annot_get_flags" poppler_annot_get_flags :: + Ptr Annot -> -- poppler_annot : TInterface (Name {namespace = "Poppler", name = "Annot"}) + IO CUInt + +{- | +Retrieves the flag field specifying various characteristics of the +/@popplerAnnot@/. +-} +annotGetFlags :: + (B.CallStack.HasCallStack, MonadIO m, IsAnnot a) => + a + {- ^ /@popplerAnnot@/: a 'GI.Poppler.Objects.Annot.Annot' -} + -> m [Poppler.Flags.AnnotFlag] + {- ^ __Returns:__ the flag field of /@popplerAnnot@/. -} +annotGetFlags popplerAnnot = liftIO $ do + popplerAnnot' <- unsafeManagedPtrCastPtr popplerAnnot + result <- poppler_annot_get_flags popplerAnnot' + let result' = wordToGFlags result + touchManagedPtr popplerAnnot + return result' + +#if ENABLE_OVERLOADING +data AnnotGetFlagsMethodInfo +instance (signature ~ (m [Poppler.Flags.AnnotFlag]), MonadIO m, IsAnnot a) => O.MethodInfo AnnotGetFlagsMethodInfo a signature where + overloadedMethod _ = annotGetFlags + +#endif + +-- method Annot::get_modified +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_annot", argType = TInterface (Name {namespace = "Poppler", name = "Annot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerAnnot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_annot_get_modified" poppler_annot_get_modified :: + Ptr Annot -> -- poppler_annot : TInterface (Name {namespace = "Poppler", name = "Annot"}) + IO CString + +{- | +Retrieves the last modification data of /@popplerAnnot@/. The returned +string will be either a PDF format date or a text string. +See also @/poppler_date_parse/@() +-} +annotGetModified :: + (B.CallStack.HasCallStack, MonadIO m, IsAnnot a) => + a + {- ^ /@popplerAnnot@/: a 'GI.Poppler.Objects.Annot.Annot' -} + -> m T.Text + {- ^ __Returns:__ a new allocated string with the last modification data of + /@popplerAnnot@/. It must be freed with 'GI.GLib.Functions.free' when done. -} +annotGetModified popplerAnnot = liftIO $ do + popplerAnnot' <- unsafeManagedPtrCastPtr popplerAnnot + result <- poppler_annot_get_modified popplerAnnot' + checkUnexpectedReturnNULL "annotGetModified" result + result' <- cstringToText result + freeMem result + touchManagedPtr popplerAnnot + return result' + +#if ENABLE_OVERLOADING +data AnnotGetModifiedMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsAnnot a) => O.MethodInfo AnnotGetModifiedMethodInfo a signature where + overloadedMethod _ = annotGetModified + +#endif + +-- method Annot::get_name +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_annot", argType = TInterface (Name {namespace = "Poppler", name = "Annot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerAnnot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_annot_get_name" poppler_annot_get_name :: + Ptr Annot -> -- poppler_annot : TInterface (Name {namespace = "Poppler", name = "Annot"}) + IO CString + +{- | +Retrieves the name of /@popplerAnnot@/. +-} +annotGetName :: + (B.CallStack.HasCallStack, MonadIO m, IsAnnot a) => + a + {- ^ /@popplerAnnot@/: a 'GI.Poppler.Objects.Annot.Annot' -} + -> m T.Text + {- ^ __Returns:__ a new allocated string with the name of /@popplerAnnot@/. It must + be freed with 'GI.GLib.Functions.free' when done. -} +annotGetName popplerAnnot = liftIO $ do + popplerAnnot' <- unsafeManagedPtrCastPtr popplerAnnot + result <- poppler_annot_get_name popplerAnnot' + checkUnexpectedReturnNULL "annotGetName" result + result' <- cstringToText result + freeMem result + touchManagedPtr popplerAnnot + return result' + +#if ENABLE_OVERLOADING +data AnnotGetNameMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsAnnot a) => O.MethodInfo AnnotGetNameMethodInfo a signature where + overloadedMethod _ = annotGetName + +#endif + +-- method Annot::get_page_index +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_annot", argType = TInterface (Name {namespace = "Poppler", name = "Annot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerAnnot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_annot_get_page_index" poppler_annot_get_page_index :: + Ptr Annot -> -- poppler_annot : TInterface (Name {namespace = "Poppler", name = "Annot"}) + IO Int32 + +{- | +Returns the page index to which /@popplerAnnot@/ is associated, or -1 if unknown + +/Since: 0.14/ +-} +annotGetPageIndex :: + (B.CallStack.HasCallStack, MonadIO m, IsAnnot a) => + a + {- ^ /@popplerAnnot@/: a 'GI.Poppler.Objects.Annot.Annot' -} + -> m Int32 + {- ^ __Returns:__ page index or -1 -} +annotGetPageIndex popplerAnnot = liftIO $ do + popplerAnnot' <- unsafeManagedPtrCastPtr popplerAnnot + result <- poppler_annot_get_page_index popplerAnnot' + touchManagedPtr popplerAnnot + return result + +#if ENABLE_OVERLOADING +data AnnotGetPageIndexMethodInfo +instance (signature ~ (m Int32), MonadIO m, IsAnnot a) => O.MethodInfo AnnotGetPageIndexMethodInfo a signature where + overloadedMethod _ = annotGetPageIndex + +#endif + +-- method Annot::get_rectangle +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_annot", argType = TInterface (Name {namespace = "Poppler", name = "Annot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerAnnot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "poppler_rect", argType = TInterface (Name {namespace = "Poppler", name = "Rectangle"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerRectangle to store the annotation's coordinates", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_annot_get_rectangle" poppler_annot_get_rectangle :: + Ptr Annot -> -- poppler_annot : TInterface (Name {namespace = "Poppler", name = "Annot"}) + Ptr Poppler.Rectangle.Rectangle -> -- poppler_rect : TInterface (Name {namespace = "Poppler", name = "Rectangle"}) + IO () + +{- | +Retrieves the rectangle representing the page coordinates where the +annotation /@popplerAnnot@/ is placed. + +/Since: 0.26/ +-} +annotGetRectangle :: + (B.CallStack.HasCallStack, MonadIO m, IsAnnot a) => + a + {- ^ /@popplerAnnot@/: a 'GI.Poppler.Objects.Annot.Annot' -} + -> m (Poppler.Rectangle.Rectangle) +annotGetRectangle popplerAnnot = liftIO $ do + popplerAnnot' <- unsafeManagedPtrCastPtr popplerAnnot + popplerRect <- callocBoxedBytes 32 :: IO (Ptr Poppler.Rectangle.Rectangle) + poppler_annot_get_rectangle popplerAnnot' popplerRect + popplerRect' <- (wrapBoxed Poppler.Rectangle.Rectangle) popplerRect + touchManagedPtr popplerAnnot + return popplerRect' + +#if ENABLE_OVERLOADING +data AnnotGetRectangleMethodInfo +instance (signature ~ (m (Poppler.Rectangle.Rectangle)), MonadIO m, IsAnnot a) => O.MethodInfo AnnotGetRectangleMethodInfo a signature where + overloadedMethod _ = annotGetRectangle + +#endif + +-- method Annot::set_color +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_annot", argType = TInterface (Name {namespace = "Poppler", name = "Annot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerAnnot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "poppler_color", argType = TInterface (Name {namespace = "Poppler", name = "Color"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #PopplerColor, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_annot_set_color" poppler_annot_set_color :: + Ptr Annot -> -- poppler_annot : TInterface (Name {namespace = "Poppler", name = "Annot"}) + Ptr Poppler.Color.Color -> -- poppler_color : TInterface (Name {namespace = "Poppler", name = "Color"}) + IO () + +{- | +Sets the color of /@popplerAnnot@/. + +/Since: 0.16/ +-} +annotSetColor :: + (B.CallStack.HasCallStack, MonadIO m, IsAnnot a) => + a + {- ^ /@popplerAnnot@/: a 'GI.Poppler.Objects.Annot.Annot' -} + -> Maybe (Poppler.Color.Color) + {- ^ /@popplerColor@/: a 'GI.Poppler.Structs.Color.Color', or 'Nothing' -} + -> m () +annotSetColor popplerAnnot popplerColor = liftIO $ do + popplerAnnot' <- unsafeManagedPtrCastPtr popplerAnnot + maybePopplerColor <- case popplerColor of + Nothing -> return nullPtr + Just jPopplerColor -> do + jPopplerColor' <- unsafeManagedPtrGetPtr jPopplerColor + return jPopplerColor' + poppler_annot_set_color popplerAnnot' maybePopplerColor + touchManagedPtr popplerAnnot + whenJust popplerColor touchManagedPtr + return () + +#if ENABLE_OVERLOADING +data AnnotSetColorMethodInfo +instance (signature ~ (Maybe (Poppler.Color.Color) -> m ()), MonadIO m, IsAnnot a) => O.MethodInfo AnnotSetColorMethodInfo a signature where + overloadedMethod _ = annotSetColor + +#endif + +-- method Annot::set_contents +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_annot", argType = TInterface (Name {namespace = "Poppler", name = "Annot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerAnnot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "contents", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a text string containing the new contents", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_annot_set_contents" poppler_annot_set_contents :: + Ptr Annot -> -- poppler_annot : TInterface (Name {namespace = "Poppler", name = "Annot"}) + CString -> -- contents : TBasicType TUTF8 + IO () + +{- | +Sets the contents of /@popplerAnnot@/ to the given value, +replacing the current contents. + +/Since: 0.12/ +-} +annotSetContents :: + (B.CallStack.HasCallStack, MonadIO m, IsAnnot a) => + a + {- ^ /@popplerAnnot@/: a 'GI.Poppler.Objects.Annot.Annot' -} + -> T.Text + {- ^ /@contents@/: a text string containing the new contents -} + -> m () +annotSetContents popplerAnnot contents = liftIO $ do + popplerAnnot' <- unsafeManagedPtrCastPtr popplerAnnot + contents' <- textToCString contents + poppler_annot_set_contents popplerAnnot' contents' + touchManagedPtr popplerAnnot + freeMem contents' + return () + +#if ENABLE_OVERLOADING +data AnnotSetContentsMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsAnnot a) => O.MethodInfo AnnotSetContentsMethodInfo a signature where + overloadedMethod _ = annotSetContents + +#endif + +-- method Annot::set_flags +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_annot", argType = TInterface (Name {namespace = "Poppler", name = "Annot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerAnnot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Poppler", name = "AnnotFlag"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerAnnotFlag", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_annot_set_flags" poppler_annot_set_flags :: + Ptr Annot -> -- poppler_annot : TInterface (Name {namespace = "Poppler", name = "Annot"}) + CUInt -> -- flags : TInterface (Name {namespace = "Poppler", name = "AnnotFlag"}) + IO () + +{- | +Sets the flag field specifying various characteristics of the +/@popplerAnnot@/. + +/Since: 0.22/ +-} +annotSetFlags :: + (B.CallStack.HasCallStack, MonadIO m, IsAnnot a) => + a + {- ^ /@popplerAnnot@/: a 'GI.Poppler.Objects.Annot.Annot' -} + -> [Poppler.Flags.AnnotFlag] + {- ^ /@flags@/: a 'GI.Poppler.Flags.AnnotFlag' -} + -> m () +annotSetFlags popplerAnnot flags = liftIO $ do + popplerAnnot' <- unsafeManagedPtrCastPtr popplerAnnot + let flags' = gflagsToWord flags + poppler_annot_set_flags popplerAnnot' flags' + touchManagedPtr popplerAnnot + return () + +#if ENABLE_OVERLOADING +data AnnotSetFlagsMethodInfo +instance (signature ~ ([Poppler.Flags.AnnotFlag] -> m ()), MonadIO m, IsAnnot a) => O.MethodInfo AnnotSetFlagsMethodInfo a signature where + overloadedMethod _ = annotSetFlags + +#endif + +-- method Annot::set_rectangle +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_annot", argType = TInterface (Name {namespace = "Poppler", name = "Annot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerAnnot", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "poppler_rect", argType = TInterface (Name {namespace = "Poppler", name = "Rectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerRectangle with the new annotation's coordinates", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_annot_set_rectangle" poppler_annot_set_rectangle :: + Ptr Annot -> -- poppler_annot : TInterface (Name {namespace = "Poppler", name = "Annot"}) + Ptr Poppler.Rectangle.Rectangle -> -- poppler_rect : TInterface (Name {namespace = "Poppler", name = "Rectangle"}) + IO () + +{- | +Move the annotation to the rectangle representing the page coordinates +where the annotation /@popplerAnnot@/ should be placed. + +/Since: 0.26/ +-} +annotSetRectangle :: + (B.CallStack.HasCallStack, MonadIO m, IsAnnot a) => + a + {- ^ /@popplerAnnot@/: a 'GI.Poppler.Objects.Annot.Annot' -} + -> Poppler.Rectangle.Rectangle + {- ^ /@popplerRect@/: a 'GI.Poppler.Structs.Rectangle.Rectangle' with the new annotation\'s coordinates -} + -> m () +annotSetRectangle popplerAnnot popplerRect = liftIO $ do + popplerAnnot' <- unsafeManagedPtrCastPtr popplerAnnot + popplerRect' <- unsafeManagedPtrGetPtr popplerRect + poppler_annot_set_rectangle popplerAnnot' popplerRect' + touchManagedPtr popplerAnnot + touchManagedPtr popplerRect + return () + +#if ENABLE_OVERLOADING +data AnnotSetRectangleMethodInfo +instance (signature ~ (Poppler.Rectangle.Rectangle -> m ()), MonadIO m, IsAnnot a) => O.MethodInfo AnnotSetRectangleMethodInfo a signature where + overloadedMethod _ = annotSetRectangle + +#endif + + 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,65 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Poppler.Objects.Annot where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype Annot = Annot (ManagedPtr Annot) +instance GObject Annot where +class (GObject o, O.IsDescendantOf Annot o) => IsAnnot o +instance (GObject o, O.IsDescendantOf Annot o) => IsAnnot o +instance O.HasParentTypes Annot +#if ENABLE_OVERLOADING +data AnnotGetAnnotTypeMethodInfo +#endif +#if ENABLE_OVERLOADING +data AnnotGetColorMethodInfo +#endif +#if ENABLE_OVERLOADING +data AnnotGetContentsMethodInfo +#endif +#if ENABLE_OVERLOADING +data AnnotGetFlagsMethodInfo +#endif +#if ENABLE_OVERLOADING +data AnnotGetModifiedMethodInfo +#endif +#if ENABLE_OVERLOADING +data AnnotGetNameMethodInfo +#endif +#if ENABLE_OVERLOADING +data AnnotGetPageIndexMethodInfo +#endif +#if ENABLE_OVERLOADING +data AnnotGetRectangleMethodInfo +#endif +#if ENABLE_OVERLOADING +data AnnotSetColorMethodInfo +#endif +#if ENABLE_OVERLOADING +data AnnotSetContentsMethodInfo +#endif +#if ENABLE_OVERLOADING +data AnnotSetFlagsMethodInfo +#endif +#if ENABLE_OVERLOADING +data AnnotSetRectangleMethodInfo +#endif 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,302 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Poppler.Objects.AnnotCircle + ( + +-- * Exported types + AnnotCircle(..) , + IsAnnotCircle , + toAnnotCircle , + noAnnotCircle , + + + -- * Methods +-- ** getInteriorColor #method:getInteriorColor# + +#if ENABLE_OVERLOADING + AnnotCircleGetInteriorColorMethodInfo , +#endif + annotCircleGetInteriorColor , + + +-- ** new #method:new# + + annotCircleNew , + + +-- ** setInteriorColor #method:setInteriorColor# + +#if ENABLE_OVERLOADING + AnnotCircleSetInteriorColorMethodInfo , +#endif + annotCircleSetInteriorColor , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import qualified GI.GObject.Objects.Object as GObject.Object +import {-# SOURCE #-} qualified GI.Poppler.Objects.Annot as Poppler.Annot +import {-# SOURCE #-} qualified GI.Poppler.Objects.AnnotMarkup as Poppler.AnnotMarkup +import {-# SOURCE #-} qualified GI.Poppler.Objects.Document as Poppler.Document +import {-# SOURCE #-} qualified GI.Poppler.Structs.Color as Poppler.Color +import {-# SOURCE #-} qualified GI.Poppler.Structs.Rectangle as Poppler.Rectangle + +-- | Memory-managed wrapper type. +newtype AnnotCircle = AnnotCircle (ManagedPtr AnnotCircle) +foreign import ccall "poppler_annot_circle_get_type" + c_poppler_annot_circle_get_type :: IO GType + +instance GObject AnnotCircle where + gobjectType = c_poppler_annot_circle_get_type + + +-- | Type class for types which can be safely cast to `AnnotCircle`, for instance with `toAnnotCircle`. +class (GObject o, O.IsDescendantOf AnnotCircle o) => IsAnnotCircle o +instance (GObject o, O.IsDescendantOf AnnotCircle o) => IsAnnotCircle o + +instance O.HasParentTypes AnnotCircle +type instance O.ParentTypes AnnotCircle = '[Poppler.AnnotMarkup.AnnotMarkup, Poppler.Annot.Annot, GObject.Object.Object] + +-- | Cast to `AnnotCircle`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toAnnotCircle :: (MonadIO m, IsAnnotCircle o) => o -> m AnnotCircle +toAnnotCircle = liftIO . unsafeCastTo AnnotCircle + +-- | A convenience alias for `Nothing` :: `Maybe` `AnnotCircle`. +noAnnotCircle :: Maybe AnnotCircle +noAnnotCircle = Nothing + +#if ENABLE_OVERLOADING +type family ResolveAnnotCircleMethod (t :: Symbol) (o :: *) :: * where + ResolveAnnotCircleMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveAnnotCircleMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveAnnotCircleMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveAnnotCircleMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveAnnotCircleMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveAnnotCircleMethod "hasPopup" o = Poppler.AnnotMarkup.AnnotMarkupHasPopupMethodInfo + ResolveAnnotCircleMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveAnnotCircleMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveAnnotCircleMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveAnnotCircleMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveAnnotCircleMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveAnnotCircleMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveAnnotCircleMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveAnnotCircleMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveAnnotCircleMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveAnnotCircleMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveAnnotCircleMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveAnnotCircleMethod "getAnnotType" o = Poppler.Annot.AnnotGetAnnotTypeMethodInfo + ResolveAnnotCircleMethod "getColor" o = Poppler.Annot.AnnotGetColorMethodInfo + ResolveAnnotCircleMethod "getContents" o = Poppler.Annot.AnnotGetContentsMethodInfo + ResolveAnnotCircleMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveAnnotCircleMethod "getDate" o = Poppler.AnnotMarkup.AnnotMarkupGetDateMethodInfo + ResolveAnnotCircleMethod "getExternalData" o = Poppler.AnnotMarkup.AnnotMarkupGetExternalDataMethodInfo + ResolveAnnotCircleMethod "getFlags" o = Poppler.Annot.AnnotGetFlagsMethodInfo + ResolveAnnotCircleMethod "getInteriorColor" o = AnnotCircleGetInteriorColorMethodInfo + ResolveAnnotCircleMethod "getLabel" o = Poppler.AnnotMarkup.AnnotMarkupGetLabelMethodInfo + ResolveAnnotCircleMethod "getModified" o = Poppler.Annot.AnnotGetModifiedMethodInfo + ResolveAnnotCircleMethod "getName" o = Poppler.Annot.AnnotGetNameMethodInfo + ResolveAnnotCircleMethod "getOpacity" o = Poppler.AnnotMarkup.AnnotMarkupGetOpacityMethodInfo + ResolveAnnotCircleMethod "getPageIndex" o = Poppler.Annot.AnnotGetPageIndexMethodInfo + ResolveAnnotCircleMethod "getPopupIsOpen" o = Poppler.AnnotMarkup.AnnotMarkupGetPopupIsOpenMethodInfo + ResolveAnnotCircleMethod "getPopupRectangle" o = Poppler.AnnotMarkup.AnnotMarkupGetPopupRectangleMethodInfo + ResolveAnnotCircleMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveAnnotCircleMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveAnnotCircleMethod "getRectangle" o = Poppler.Annot.AnnotGetRectangleMethodInfo + ResolveAnnotCircleMethod "getReplyTo" o = Poppler.AnnotMarkup.AnnotMarkupGetReplyToMethodInfo + ResolveAnnotCircleMethod "getSubject" o = Poppler.AnnotMarkup.AnnotMarkupGetSubjectMethodInfo + ResolveAnnotCircleMethod "setColor" o = Poppler.Annot.AnnotSetColorMethodInfo + ResolveAnnotCircleMethod "setContents" o = Poppler.Annot.AnnotSetContentsMethodInfo + ResolveAnnotCircleMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveAnnotCircleMethod "setFlags" o = Poppler.Annot.AnnotSetFlagsMethodInfo + ResolveAnnotCircleMethod "setInteriorColor" o = AnnotCircleSetInteriorColorMethodInfo + ResolveAnnotCircleMethod "setLabel" o = Poppler.AnnotMarkup.AnnotMarkupSetLabelMethodInfo + ResolveAnnotCircleMethod "setOpacity" o = Poppler.AnnotMarkup.AnnotMarkupSetOpacityMethodInfo + ResolveAnnotCircleMethod "setPopup" o = Poppler.AnnotMarkup.AnnotMarkupSetPopupMethodInfo + ResolveAnnotCircleMethod "setPopupIsOpen" o = Poppler.AnnotMarkup.AnnotMarkupSetPopupIsOpenMethodInfo + ResolveAnnotCircleMethod "setPopupRectangle" o = Poppler.AnnotMarkup.AnnotMarkupSetPopupRectangleMethodInfo + ResolveAnnotCircleMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveAnnotCircleMethod "setRectangle" o = Poppler.Annot.AnnotSetRectangleMethodInfo + ResolveAnnotCircleMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveAnnotCircleMethod t AnnotCircle, O.MethodInfo info AnnotCircle p) => OL.IsLabel t (AnnotCircle -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList AnnotCircle +type instance O.AttributeList AnnotCircle = AnnotCircleAttributeList +type AnnotCircleAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList AnnotCircle = AnnotCircleSignalList +type AnnotCircleSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method AnnotCircle::new +-- method type : Constructor +-- Args : [Arg {argCName = "doc", argType = TInterface (Name {namespace = "Poppler", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rect", argType = TInterface (Name {namespace = "Poppler", name = "Rectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerRectangle", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "AnnotCircle"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_annot_circle_new" poppler_annot_circle_new :: + Ptr Poppler.Document.Document -> -- doc : TInterface (Name {namespace = "Poppler", name = "Document"}) + Ptr Poppler.Rectangle.Rectangle -> -- rect : TInterface (Name {namespace = "Poppler", name = "Rectangle"}) + IO (Ptr AnnotCircle) + +{- | +Creates a new Circle annotation that will be +located on /@rect@/ when added to a page. See +'GI.Poppler.Objects.Page.pageAddAnnot' + +/Since: 0.26/ +-} +annotCircleNew :: + (B.CallStack.HasCallStack, MonadIO m, Poppler.Document.IsDocument a) => + a + {- ^ /@doc@/: a 'GI.Poppler.Objects.Document.Document' -} + -> Poppler.Rectangle.Rectangle + {- ^ /@rect@/: a 'GI.Poppler.Structs.Rectangle.Rectangle' -} + -> m AnnotCircle + {- ^ __Returns:__ a newly created 'GI.Poppler.Objects.AnnotCircle.AnnotCircle' annotation -} +annotCircleNew doc rect = liftIO $ do + doc' <- unsafeManagedPtrCastPtr doc + rect' <- unsafeManagedPtrGetPtr rect + result <- poppler_annot_circle_new doc' rect' + checkUnexpectedReturnNULL "annotCircleNew" result + result' <- (wrapObject AnnotCircle) result + touchManagedPtr doc + touchManagedPtr rect + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method AnnotCircle::get_interior_color +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_annot", argType = TInterface (Name {namespace = "Poppler", name = "AnnotCircle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerAnnotCircle", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "Color"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_annot_circle_get_interior_color" poppler_annot_circle_get_interior_color :: + Ptr AnnotCircle -> -- poppler_annot : TInterface (Name {namespace = "Poppler", name = "AnnotCircle"}) + IO (Ptr Poppler.Color.Color) + +{- | +Retrieves the interior color of /@popplerAnnot@/. + +/Since: 0.26/ +-} +annotCircleGetInteriorColor :: + (B.CallStack.HasCallStack, MonadIO m, IsAnnotCircle a) => + a + {- ^ /@popplerAnnot@/: a 'GI.Poppler.Objects.AnnotCircle.AnnotCircle' -} + -> m Poppler.Color.Color + {- ^ __Returns:__ a new allocated 'GI.Poppler.Structs.Color.Color' with the color values of + /@popplerAnnot@/, or 'Nothing'. It must be freed with 'GI.GLib.Functions.free' when done. -} +annotCircleGetInteriorColor popplerAnnot = liftIO $ do + popplerAnnot' <- unsafeManagedPtrCastPtr popplerAnnot + result <- poppler_annot_circle_get_interior_color popplerAnnot' + checkUnexpectedReturnNULL "annotCircleGetInteriorColor" result + result' <- (wrapBoxed Poppler.Color.Color) result + touchManagedPtr popplerAnnot + return result' + +#if ENABLE_OVERLOADING +data AnnotCircleGetInteriorColorMethodInfo +instance (signature ~ (m Poppler.Color.Color), MonadIO m, IsAnnotCircle a) => O.MethodInfo AnnotCircleGetInteriorColorMethodInfo a signature where + overloadedMethod _ = annotCircleGetInteriorColor + +#endif + +-- method AnnotCircle::set_interior_color +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_annot", argType = TInterface (Name {namespace = "Poppler", name = "AnnotCircle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerAnnotCircle", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "poppler_color", argType = TInterface (Name {namespace = "Poppler", name = "Color"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #PopplerColor, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_annot_circle_set_interior_color" poppler_annot_circle_set_interior_color :: + Ptr AnnotCircle -> -- poppler_annot : TInterface (Name {namespace = "Poppler", name = "AnnotCircle"}) + Ptr Poppler.Color.Color -> -- poppler_color : TInterface (Name {namespace = "Poppler", name = "Color"}) + IO () + +{- | +Sets the interior color of /@popplerAnnot@/. + +/Since: 0.26/ +-} +annotCircleSetInteriorColor :: + (B.CallStack.HasCallStack, MonadIO m, IsAnnotCircle a) => + a + {- ^ /@popplerAnnot@/: a 'GI.Poppler.Objects.AnnotCircle.AnnotCircle' -} + -> Maybe (Poppler.Color.Color) + {- ^ /@popplerColor@/: a 'GI.Poppler.Structs.Color.Color', or 'Nothing' -} + -> m () +annotCircleSetInteriorColor popplerAnnot popplerColor = liftIO $ do + popplerAnnot' <- unsafeManagedPtrCastPtr popplerAnnot + maybePopplerColor <- case popplerColor of + Nothing -> return nullPtr + Just jPopplerColor -> do + jPopplerColor' <- unsafeManagedPtrGetPtr jPopplerColor + return jPopplerColor' + poppler_annot_circle_set_interior_color popplerAnnot' maybePopplerColor + touchManagedPtr popplerAnnot + whenJust popplerColor touchManagedPtr + return () + +#if ENABLE_OVERLOADING +data AnnotCircleSetInteriorColorMethodInfo +instance (signature ~ (Maybe (Poppler.Color.Color) -> m ()), MonadIO m, IsAnnotCircle a) => O.MethodInfo AnnotCircleSetInteriorColorMethodInfo a signature where + overloadedMethod _ = annotCircleSetInteriorColor + +#endif + + 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,35 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Poppler.Objects.AnnotCircle where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype AnnotCircle = AnnotCircle (ManagedPtr AnnotCircle) +instance GObject AnnotCircle where +class (GObject o, O.IsDescendantOf AnnotCircle o) => IsAnnotCircle o +instance (GObject o, O.IsDescendantOf AnnotCircle o) => IsAnnotCircle o +instance O.HasParentTypes AnnotCircle +#if ENABLE_OVERLOADING +data AnnotCircleGetInteriorColorMethodInfo +#endif +#if ENABLE_OVERLOADING +data AnnotCircleSetInteriorColorMethodInfo +#endif 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,249 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Poppler.Objects.AnnotFileAttachment + ( + +-- * Exported types + AnnotFileAttachment(..) , + IsAnnotFileAttachment , + toAnnotFileAttachment , + noAnnotFileAttachment , + + + -- * Methods +-- ** getAttachment #method:getAttachment# + +#if ENABLE_OVERLOADING + AnnotFileAttachmentGetAttachmentMethodInfo, +#endif + annotFileAttachmentGetAttachment , + + +-- ** getName #method:getName# + +#if ENABLE_OVERLOADING + AnnotFileAttachmentGetNameMethodInfo , +#endif + annotFileAttachmentGetName , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import qualified GI.GObject.Objects.Object as GObject.Object +import {-# SOURCE #-} qualified GI.Poppler.Objects.Annot as Poppler.Annot +import {-# SOURCE #-} qualified GI.Poppler.Objects.AnnotMarkup as Poppler.AnnotMarkup +import {-# SOURCE #-} qualified GI.Poppler.Objects.Attachment as Poppler.Attachment + +-- | Memory-managed wrapper type. +newtype AnnotFileAttachment = AnnotFileAttachment (ManagedPtr AnnotFileAttachment) +foreign import ccall "poppler_annot_file_attachment_get_type" + c_poppler_annot_file_attachment_get_type :: IO GType + +instance GObject AnnotFileAttachment where + gobjectType = c_poppler_annot_file_attachment_get_type + + +-- | Type class for types which can be safely cast to `AnnotFileAttachment`, for instance with `toAnnotFileAttachment`. +class (GObject o, O.IsDescendantOf AnnotFileAttachment o) => IsAnnotFileAttachment o +instance (GObject o, O.IsDescendantOf AnnotFileAttachment o) => IsAnnotFileAttachment o + +instance O.HasParentTypes AnnotFileAttachment +type instance O.ParentTypes AnnotFileAttachment = '[Poppler.AnnotMarkup.AnnotMarkup, Poppler.Annot.Annot, GObject.Object.Object] + +-- | Cast to `AnnotFileAttachment`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toAnnotFileAttachment :: (MonadIO m, IsAnnotFileAttachment o) => o -> m AnnotFileAttachment +toAnnotFileAttachment = liftIO . unsafeCastTo AnnotFileAttachment + +-- | A convenience alias for `Nothing` :: `Maybe` `AnnotFileAttachment`. +noAnnotFileAttachment :: Maybe AnnotFileAttachment +noAnnotFileAttachment = Nothing + +#if ENABLE_OVERLOADING +type family ResolveAnnotFileAttachmentMethod (t :: Symbol) (o :: *) :: * where + ResolveAnnotFileAttachmentMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveAnnotFileAttachmentMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveAnnotFileAttachmentMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveAnnotFileAttachmentMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveAnnotFileAttachmentMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveAnnotFileAttachmentMethod "hasPopup" o = Poppler.AnnotMarkup.AnnotMarkupHasPopupMethodInfo + ResolveAnnotFileAttachmentMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveAnnotFileAttachmentMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveAnnotFileAttachmentMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveAnnotFileAttachmentMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveAnnotFileAttachmentMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveAnnotFileAttachmentMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveAnnotFileAttachmentMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveAnnotFileAttachmentMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveAnnotFileAttachmentMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveAnnotFileAttachmentMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveAnnotFileAttachmentMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveAnnotFileAttachmentMethod "getAnnotType" o = Poppler.Annot.AnnotGetAnnotTypeMethodInfo + ResolveAnnotFileAttachmentMethod "getAttachment" o = AnnotFileAttachmentGetAttachmentMethodInfo + ResolveAnnotFileAttachmentMethod "getColor" o = Poppler.Annot.AnnotGetColorMethodInfo + ResolveAnnotFileAttachmentMethod "getContents" o = Poppler.Annot.AnnotGetContentsMethodInfo + ResolveAnnotFileAttachmentMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveAnnotFileAttachmentMethod "getDate" o = Poppler.AnnotMarkup.AnnotMarkupGetDateMethodInfo + ResolveAnnotFileAttachmentMethod "getExternalData" o = Poppler.AnnotMarkup.AnnotMarkupGetExternalDataMethodInfo + ResolveAnnotFileAttachmentMethod "getFlags" o = Poppler.Annot.AnnotGetFlagsMethodInfo + ResolveAnnotFileAttachmentMethod "getLabel" o = Poppler.AnnotMarkup.AnnotMarkupGetLabelMethodInfo + ResolveAnnotFileAttachmentMethod "getModified" o = Poppler.Annot.AnnotGetModifiedMethodInfo + ResolveAnnotFileAttachmentMethod "getName" o = AnnotFileAttachmentGetNameMethodInfo + ResolveAnnotFileAttachmentMethod "getOpacity" o = Poppler.AnnotMarkup.AnnotMarkupGetOpacityMethodInfo + ResolveAnnotFileAttachmentMethod "getPageIndex" o = Poppler.Annot.AnnotGetPageIndexMethodInfo + ResolveAnnotFileAttachmentMethod "getPopupIsOpen" o = Poppler.AnnotMarkup.AnnotMarkupGetPopupIsOpenMethodInfo + ResolveAnnotFileAttachmentMethod "getPopupRectangle" o = Poppler.AnnotMarkup.AnnotMarkupGetPopupRectangleMethodInfo + ResolveAnnotFileAttachmentMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveAnnotFileAttachmentMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveAnnotFileAttachmentMethod "getRectangle" o = Poppler.Annot.AnnotGetRectangleMethodInfo + ResolveAnnotFileAttachmentMethod "getReplyTo" o = Poppler.AnnotMarkup.AnnotMarkupGetReplyToMethodInfo + ResolveAnnotFileAttachmentMethod "getSubject" o = Poppler.AnnotMarkup.AnnotMarkupGetSubjectMethodInfo + ResolveAnnotFileAttachmentMethod "setColor" o = Poppler.Annot.AnnotSetColorMethodInfo + ResolveAnnotFileAttachmentMethod "setContents" o = Poppler.Annot.AnnotSetContentsMethodInfo + ResolveAnnotFileAttachmentMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveAnnotFileAttachmentMethod "setFlags" o = Poppler.Annot.AnnotSetFlagsMethodInfo + ResolveAnnotFileAttachmentMethod "setLabel" o = Poppler.AnnotMarkup.AnnotMarkupSetLabelMethodInfo + ResolveAnnotFileAttachmentMethod "setOpacity" o = Poppler.AnnotMarkup.AnnotMarkupSetOpacityMethodInfo + ResolveAnnotFileAttachmentMethod "setPopup" o = Poppler.AnnotMarkup.AnnotMarkupSetPopupMethodInfo + ResolveAnnotFileAttachmentMethod "setPopupIsOpen" o = Poppler.AnnotMarkup.AnnotMarkupSetPopupIsOpenMethodInfo + ResolveAnnotFileAttachmentMethod "setPopupRectangle" o = Poppler.AnnotMarkup.AnnotMarkupSetPopupRectangleMethodInfo + ResolveAnnotFileAttachmentMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveAnnotFileAttachmentMethod "setRectangle" o = Poppler.Annot.AnnotSetRectangleMethodInfo + ResolveAnnotFileAttachmentMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveAnnotFileAttachmentMethod t AnnotFileAttachment, O.MethodInfo info AnnotFileAttachment p) => OL.IsLabel t (AnnotFileAttachment -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList AnnotFileAttachment +type instance O.AttributeList AnnotFileAttachment = AnnotFileAttachmentAttributeList +type AnnotFileAttachmentAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList AnnotFileAttachment = AnnotFileAttachmentSignalList +type AnnotFileAttachmentSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method AnnotFileAttachment::get_attachment +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_annot", argType = TInterface (Name {namespace = "Poppler", name = "AnnotFileAttachment"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerAnnotFileAttachment", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "Attachment"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_annot_file_attachment_get_attachment" poppler_annot_file_attachment_get_attachment :: + Ptr AnnotFileAttachment -> -- poppler_annot : TInterface (Name {namespace = "Poppler", name = "AnnotFileAttachment"}) + IO (Ptr Poppler.Attachment.Attachment) + +{- | +Creates a 'GI.Poppler.Objects.Attachment.Attachment' for the file of the file attachment annotation /@annot@/. +The 'GI.Poppler.Objects.Attachment.Attachment' must be unrefed with g_object_unref by the caller. + +/Since: 0.14/ +-} +annotFileAttachmentGetAttachment :: + (B.CallStack.HasCallStack, MonadIO m, IsAnnotFileAttachment a) => + a + {- ^ /@popplerAnnot@/: a 'GI.Poppler.Objects.AnnotFileAttachment.AnnotFileAttachment' -} + -> m Poppler.Attachment.Attachment + {- ^ __Returns:__ /@popplerAttachment@/ -} +annotFileAttachmentGetAttachment popplerAnnot = liftIO $ do + popplerAnnot' <- unsafeManagedPtrCastPtr popplerAnnot + result <- poppler_annot_file_attachment_get_attachment popplerAnnot' + checkUnexpectedReturnNULL "annotFileAttachmentGetAttachment" result + result' <- (wrapObject Poppler.Attachment.Attachment) result + touchManagedPtr popplerAnnot + return result' + +#if ENABLE_OVERLOADING +data AnnotFileAttachmentGetAttachmentMethodInfo +instance (signature ~ (m Poppler.Attachment.Attachment), MonadIO m, IsAnnotFileAttachment a) => O.MethodInfo AnnotFileAttachmentGetAttachmentMethodInfo a signature where + overloadedMethod _ = annotFileAttachmentGetAttachment + +#endif + +-- method AnnotFileAttachment::get_name +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_annot", argType = TInterface (Name {namespace = "Poppler", name = "AnnotFileAttachment"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerAnnotFileAttachment", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_annot_file_attachment_get_name" poppler_annot_file_attachment_get_name :: + Ptr AnnotFileAttachment -> -- poppler_annot : TInterface (Name {namespace = "Poppler", name = "AnnotFileAttachment"}) + IO CString + +{- | +Retrieves the name of /@popplerAnnot@/. + +/Since: 0.14/ +-} +annotFileAttachmentGetName :: + (B.CallStack.HasCallStack, MonadIO m, IsAnnotFileAttachment a) => + a + {- ^ /@popplerAnnot@/: a 'GI.Poppler.Objects.AnnotFileAttachment.AnnotFileAttachment' -} + -> m T.Text + {- ^ __Returns:__ a new allocated string with the name of /@popplerAnnot@/. It must + be freed with 'GI.GLib.Functions.free' when done. -} +annotFileAttachmentGetName popplerAnnot = liftIO $ do + popplerAnnot' <- unsafeManagedPtrCastPtr popplerAnnot + result <- poppler_annot_file_attachment_get_name popplerAnnot' + checkUnexpectedReturnNULL "annotFileAttachmentGetName" result + result' <- cstringToText result + freeMem result + touchManagedPtr popplerAnnot + return result' + +#if ENABLE_OVERLOADING +data AnnotFileAttachmentGetNameMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsAnnotFileAttachment a) => O.MethodInfo AnnotFileAttachmentGetNameMethodInfo a signature where + overloadedMethod _ = annotFileAttachmentGetName + +#endif + + 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,35 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Poppler.Objects.AnnotFileAttachment where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype AnnotFileAttachment = AnnotFileAttachment (ManagedPtr AnnotFileAttachment) +instance GObject AnnotFileAttachment where +class (GObject o, O.IsDescendantOf AnnotFileAttachment o) => IsAnnotFileAttachment o +instance (GObject o, O.IsDescendantOf AnnotFileAttachment o) => IsAnnotFileAttachment o +instance O.HasParentTypes AnnotFileAttachment +#if ENABLE_OVERLOADING +data AnnotFileAttachmentGetAttachmentMethodInfo +#endif +#if ENABLE_OVERLOADING +data AnnotFileAttachmentGetNameMethodInfo +#endif 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,246 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Poppler.Objects.AnnotFreeText + ( + +-- * Exported types + AnnotFreeText(..) , + IsAnnotFreeText , + toAnnotFreeText , + noAnnotFreeText , + + + -- * Methods +-- ** getCalloutLine #method:getCalloutLine# + +#if ENABLE_OVERLOADING + AnnotFreeTextGetCalloutLineMethodInfo , +#endif + annotFreeTextGetCalloutLine , + + +-- ** getQuadding #method:getQuadding# + +#if ENABLE_OVERLOADING + AnnotFreeTextGetQuaddingMethodInfo , +#endif + annotFreeTextGetQuadding , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import qualified GI.GObject.Objects.Object as GObject.Object +import {-# SOURCE #-} qualified GI.Poppler.Enums as Poppler.Enums +import {-# SOURCE #-} qualified GI.Poppler.Objects.Annot as Poppler.Annot +import {-# SOURCE #-} qualified GI.Poppler.Objects.AnnotMarkup as Poppler.AnnotMarkup +import {-# SOURCE #-} qualified GI.Poppler.Structs.AnnotCalloutLine as Poppler.AnnotCalloutLine + +-- | Memory-managed wrapper type. +newtype AnnotFreeText = AnnotFreeText (ManagedPtr AnnotFreeText) +foreign import ccall "poppler_annot_free_text_get_type" + c_poppler_annot_free_text_get_type :: IO GType + +instance GObject AnnotFreeText where + gobjectType = c_poppler_annot_free_text_get_type + + +-- | Type class for types which can be safely cast to `AnnotFreeText`, for instance with `toAnnotFreeText`. +class (GObject o, O.IsDescendantOf AnnotFreeText o) => IsAnnotFreeText o +instance (GObject o, O.IsDescendantOf AnnotFreeText o) => IsAnnotFreeText o + +instance O.HasParentTypes AnnotFreeText +type instance O.ParentTypes AnnotFreeText = '[Poppler.AnnotMarkup.AnnotMarkup, Poppler.Annot.Annot, GObject.Object.Object] + +-- | Cast to `AnnotFreeText`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toAnnotFreeText :: (MonadIO m, IsAnnotFreeText o) => o -> m AnnotFreeText +toAnnotFreeText = liftIO . unsafeCastTo AnnotFreeText + +-- | A convenience alias for `Nothing` :: `Maybe` `AnnotFreeText`. +noAnnotFreeText :: Maybe AnnotFreeText +noAnnotFreeText = Nothing + +#if ENABLE_OVERLOADING +type family ResolveAnnotFreeTextMethod (t :: Symbol) (o :: *) :: * where + ResolveAnnotFreeTextMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveAnnotFreeTextMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveAnnotFreeTextMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveAnnotFreeTextMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveAnnotFreeTextMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveAnnotFreeTextMethod "hasPopup" o = Poppler.AnnotMarkup.AnnotMarkupHasPopupMethodInfo + ResolveAnnotFreeTextMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveAnnotFreeTextMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveAnnotFreeTextMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveAnnotFreeTextMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveAnnotFreeTextMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveAnnotFreeTextMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveAnnotFreeTextMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveAnnotFreeTextMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveAnnotFreeTextMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveAnnotFreeTextMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveAnnotFreeTextMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveAnnotFreeTextMethod "getAnnotType" o = Poppler.Annot.AnnotGetAnnotTypeMethodInfo + ResolveAnnotFreeTextMethod "getCalloutLine" o = AnnotFreeTextGetCalloutLineMethodInfo + ResolveAnnotFreeTextMethod "getColor" o = Poppler.Annot.AnnotGetColorMethodInfo + ResolveAnnotFreeTextMethod "getContents" o = Poppler.Annot.AnnotGetContentsMethodInfo + ResolveAnnotFreeTextMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveAnnotFreeTextMethod "getDate" o = Poppler.AnnotMarkup.AnnotMarkupGetDateMethodInfo + ResolveAnnotFreeTextMethod "getExternalData" o = Poppler.AnnotMarkup.AnnotMarkupGetExternalDataMethodInfo + ResolveAnnotFreeTextMethod "getFlags" o = Poppler.Annot.AnnotGetFlagsMethodInfo + ResolveAnnotFreeTextMethod "getLabel" o = Poppler.AnnotMarkup.AnnotMarkupGetLabelMethodInfo + ResolveAnnotFreeTextMethod "getModified" o = Poppler.Annot.AnnotGetModifiedMethodInfo + ResolveAnnotFreeTextMethod "getName" o = Poppler.Annot.AnnotGetNameMethodInfo + ResolveAnnotFreeTextMethod "getOpacity" o = Poppler.AnnotMarkup.AnnotMarkupGetOpacityMethodInfo + ResolveAnnotFreeTextMethod "getPageIndex" o = Poppler.Annot.AnnotGetPageIndexMethodInfo + ResolveAnnotFreeTextMethod "getPopupIsOpen" o = Poppler.AnnotMarkup.AnnotMarkupGetPopupIsOpenMethodInfo + ResolveAnnotFreeTextMethod "getPopupRectangle" o = Poppler.AnnotMarkup.AnnotMarkupGetPopupRectangleMethodInfo + ResolveAnnotFreeTextMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveAnnotFreeTextMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveAnnotFreeTextMethod "getQuadding" o = AnnotFreeTextGetQuaddingMethodInfo + ResolveAnnotFreeTextMethod "getRectangle" o = Poppler.Annot.AnnotGetRectangleMethodInfo + ResolveAnnotFreeTextMethod "getReplyTo" o = Poppler.AnnotMarkup.AnnotMarkupGetReplyToMethodInfo + ResolveAnnotFreeTextMethod "getSubject" o = Poppler.AnnotMarkup.AnnotMarkupGetSubjectMethodInfo + ResolveAnnotFreeTextMethod "setColor" o = Poppler.Annot.AnnotSetColorMethodInfo + ResolveAnnotFreeTextMethod "setContents" o = Poppler.Annot.AnnotSetContentsMethodInfo + ResolveAnnotFreeTextMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveAnnotFreeTextMethod "setFlags" o = Poppler.Annot.AnnotSetFlagsMethodInfo + ResolveAnnotFreeTextMethod "setLabel" o = Poppler.AnnotMarkup.AnnotMarkupSetLabelMethodInfo + ResolveAnnotFreeTextMethod "setOpacity" o = Poppler.AnnotMarkup.AnnotMarkupSetOpacityMethodInfo + ResolveAnnotFreeTextMethod "setPopup" o = Poppler.AnnotMarkup.AnnotMarkupSetPopupMethodInfo + ResolveAnnotFreeTextMethod "setPopupIsOpen" o = Poppler.AnnotMarkup.AnnotMarkupSetPopupIsOpenMethodInfo + ResolveAnnotFreeTextMethod "setPopupRectangle" o = Poppler.AnnotMarkup.AnnotMarkupSetPopupRectangleMethodInfo + ResolveAnnotFreeTextMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveAnnotFreeTextMethod "setRectangle" o = Poppler.Annot.AnnotSetRectangleMethodInfo + ResolveAnnotFreeTextMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveAnnotFreeTextMethod t AnnotFreeText, O.MethodInfo info AnnotFreeText p) => OL.IsLabel t (AnnotFreeText -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList AnnotFreeText +type instance O.AttributeList AnnotFreeText = AnnotFreeTextAttributeList +type AnnotFreeTextAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList AnnotFreeText = AnnotFreeTextSignalList +type AnnotFreeTextSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method AnnotFreeText::get_callout_line +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_annot", argType = TInterface (Name {namespace = "Poppler", name = "AnnotFreeText"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerAnnotFreeText", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "AnnotCalloutLine"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_annot_free_text_get_callout_line" poppler_annot_free_text_get_callout_line :: + Ptr AnnotFreeText -> -- poppler_annot : TInterface (Name {namespace = "Poppler", name = "AnnotFreeText"}) + IO (Ptr Poppler.AnnotCalloutLine.AnnotCalloutLine) + +{- | +Retrieves a 'GI.Poppler.Structs.AnnotCalloutLine.AnnotCalloutLine' of four or six numbers specifying a callout +line attached to the /@popplerAnnot@/. +-} +annotFreeTextGetCalloutLine :: + (B.CallStack.HasCallStack, MonadIO m, IsAnnotFreeText a) => + a + {- ^ /@popplerAnnot@/: a 'GI.Poppler.Objects.AnnotFreeText.AnnotFreeText' -} + -> m Poppler.AnnotCalloutLine.AnnotCalloutLine + {- ^ __Returns:__ a new allocated 'GI.Poppler.Structs.AnnotCalloutLine.AnnotCalloutLine' if the annot has a callout + line, 'Nothing' in other case. It must be freed with 'GI.GLib.Functions.free' when + done. -} +annotFreeTextGetCalloutLine popplerAnnot = liftIO $ do + popplerAnnot' <- unsafeManagedPtrCastPtr popplerAnnot + result <- poppler_annot_free_text_get_callout_line popplerAnnot' + checkUnexpectedReturnNULL "annotFreeTextGetCalloutLine" result + result' <- (wrapBoxed Poppler.AnnotCalloutLine.AnnotCalloutLine) result + touchManagedPtr popplerAnnot + return result' + +#if ENABLE_OVERLOADING +data AnnotFreeTextGetCalloutLineMethodInfo +instance (signature ~ (m Poppler.AnnotCalloutLine.AnnotCalloutLine), MonadIO m, IsAnnotFreeText a) => O.MethodInfo AnnotFreeTextGetCalloutLineMethodInfo a signature where + overloadedMethod _ = annotFreeTextGetCalloutLine + +#endif + +-- method AnnotFreeText::get_quadding +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_annot", argType = TInterface (Name {namespace = "Poppler", name = "AnnotFreeText"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerAnnotFreeText", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "AnnotFreeTextQuadding"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_annot_free_text_get_quadding" poppler_annot_free_text_get_quadding :: + Ptr AnnotFreeText -> -- poppler_annot : TInterface (Name {namespace = "Poppler", name = "AnnotFreeText"}) + IO CUInt + +{- | +Retrieves the justification of the text of /@popplerAnnot@/. +-} +annotFreeTextGetQuadding :: + (B.CallStack.HasCallStack, MonadIO m, IsAnnotFreeText a) => + a + {- ^ /@popplerAnnot@/: a 'GI.Poppler.Objects.AnnotFreeText.AnnotFreeText' -} + -> m Poppler.Enums.AnnotFreeTextQuadding + {- ^ __Returns:__ 'GI.Poppler.Enums.AnnotFreeTextQuadding' of /@popplerAnnot@/. -} +annotFreeTextGetQuadding popplerAnnot = liftIO $ do + popplerAnnot' <- unsafeManagedPtrCastPtr popplerAnnot + result <- poppler_annot_free_text_get_quadding popplerAnnot' + let result' = (toEnum . fromIntegral) result + touchManagedPtr popplerAnnot + return result' + +#if ENABLE_OVERLOADING +data AnnotFreeTextGetQuaddingMethodInfo +instance (signature ~ (m Poppler.Enums.AnnotFreeTextQuadding), MonadIO m, IsAnnotFreeText a) => O.MethodInfo AnnotFreeTextGetQuaddingMethodInfo a signature where + overloadedMethod _ = annotFreeTextGetQuadding + +#endif + + 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,35 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Poppler.Objects.AnnotFreeText where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype AnnotFreeText = AnnotFreeText (ManagedPtr AnnotFreeText) +instance GObject AnnotFreeText where +class (GObject o, O.IsDescendantOf AnnotFreeText o) => IsAnnotFreeText o +instance (GObject o, O.IsDescendantOf AnnotFreeText o) => IsAnnotFreeText o +instance O.HasParentTypes AnnotFreeText +#if ENABLE_OVERLOADING +data AnnotFreeTextGetCalloutLineMethodInfo +#endif +#if ENABLE_OVERLOADING +data AnnotFreeTextGetQuaddingMethodInfo +#endif 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,265 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Poppler.Objects.AnnotLine + ( + +-- * Exported types + AnnotLine(..) , + IsAnnotLine , + toAnnotLine , + noAnnotLine , + + + -- * Methods +-- ** new #method:new# + + annotLineNew , + + +-- ** setVertices #method:setVertices# + +#if ENABLE_OVERLOADING + AnnotLineSetVerticesMethodInfo , +#endif + annotLineSetVertices , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import qualified GI.GObject.Objects.Object as GObject.Object +import {-# SOURCE #-} qualified GI.Poppler.Objects.Annot as Poppler.Annot +import {-# SOURCE #-} qualified GI.Poppler.Objects.AnnotMarkup as Poppler.AnnotMarkup +import {-# SOURCE #-} qualified GI.Poppler.Objects.Document as Poppler.Document +import {-# SOURCE #-} qualified GI.Poppler.Structs.Point as Poppler.Point +import {-# SOURCE #-} qualified GI.Poppler.Structs.Rectangle as Poppler.Rectangle + +-- | Memory-managed wrapper type. +newtype AnnotLine = AnnotLine (ManagedPtr AnnotLine) +foreign import ccall "poppler_annot_line_get_type" + c_poppler_annot_line_get_type :: IO GType + +instance GObject AnnotLine where + gobjectType = c_poppler_annot_line_get_type + + +-- | Type class for types which can be safely cast to `AnnotLine`, for instance with `toAnnotLine`. +class (GObject o, O.IsDescendantOf AnnotLine o) => IsAnnotLine o +instance (GObject o, O.IsDescendantOf AnnotLine o) => IsAnnotLine o + +instance O.HasParentTypes AnnotLine +type instance O.ParentTypes AnnotLine = '[Poppler.AnnotMarkup.AnnotMarkup, Poppler.Annot.Annot, GObject.Object.Object] + +-- | Cast to `AnnotLine`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toAnnotLine :: (MonadIO m, IsAnnotLine o) => o -> m AnnotLine +toAnnotLine = liftIO . unsafeCastTo AnnotLine + +-- | A convenience alias for `Nothing` :: `Maybe` `AnnotLine`. +noAnnotLine :: Maybe AnnotLine +noAnnotLine = Nothing + +#if ENABLE_OVERLOADING +type family ResolveAnnotLineMethod (t :: Symbol) (o :: *) :: * where + ResolveAnnotLineMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveAnnotLineMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveAnnotLineMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveAnnotLineMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveAnnotLineMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveAnnotLineMethod "hasPopup" o = Poppler.AnnotMarkup.AnnotMarkupHasPopupMethodInfo + ResolveAnnotLineMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveAnnotLineMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveAnnotLineMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveAnnotLineMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveAnnotLineMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveAnnotLineMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveAnnotLineMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveAnnotLineMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveAnnotLineMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveAnnotLineMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveAnnotLineMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveAnnotLineMethod "getAnnotType" o = Poppler.Annot.AnnotGetAnnotTypeMethodInfo + ResolveAnnotLineMethod "getColor" o = Poppler.Annot.AnnotGetColorMethodInfo + ResolveAnnotLineMethod "getContents" o = Poppler.Annot.AnnotGetContentsMethodInfo + ResolveAnnotLineMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveAnnotLineMethod "getDate" o = Poppler.AnnotMarkup.AnnotMarkupGetDateMethodInfo + ResolveAnnotLineMethod "getExternalData" o = Poppler.AnnotMarkup.AnnotMarkupGetExternalDataMethodInfo + ResolveAnnotLineMethod "getFlags" o = Poppler.Annot.AnnotGetFlagsMethodInfo + ResolveAnnotLineMethod "getLabel" o = Poppler.AnnotMarkup.AnnotMarkupGetLabelMethodInfo + ResolveAnnotLineMethod "getModified" o = Poppler.Annot.AnnotGetModifiedMethodInfo + ResolveAnnotLineMethod "getName" o = Poppler.Annot.AnnotGetNameMethodInfo + ResolveAnnotLineMethod "getOpacity" o = Poppler.AnnotMarkup.AnnotMarkupGetOpacityMethodInfo + ResolveAnnotLineMethod "getPageIndex" o = Poppler.Annot.AnnotGetPageIndexMethodInfo + ResolveAnnotLineMethod "getPopupIsOpen" o = Poppler.AnnotMarkup.AnnotMarkupGetPopupIsOpenMethodInfo + ResolveAnnotLineMethod "getPopupRectangle" o = Poppler.AnnotMarkup.AnnotMarkupGetPopupRectangleMethodInfo + ResolveAnnotLineMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveAnnotLineMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveAnnotLineMethod "getRectangle" o = Poppler.Annot.AnnotGetRectangleMethodInfo + ResolveAnnotLineMethod "getReplyTo" o = Poppler.AnnotMarkup.AnnotMarkupGetReplyToMethodInfo + ResolveAnnotLineMethod "getSubject" o = Poppler.AnnotMarkup.AnnotMarkupGetSubjectMethodInfo + ResolveAnnotLineMethod "setColor" o = Poppler.Annot.AnnotSetColorMethodInfo + ResolveAnnotLineMethod "setContents" o = Poppler.Annot.AnnotSetContentsMethodInfo + ResolveAnnotLineMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveAnnotLineMethod "setFlags" o = Poppler.Annot.AnnotSetFlagsMethodInfo + ResolveAnnotLineMethod "setLabel" o = Poppler.AnnotMarkup.AnnotMarkupSetLabelMethodInfo + ResolveAnnotLineMethod "setOpacity" o = Poppler.AnnotMarkup.AnnotMarkupSetOpacityMethodInfo + ResolveAnnotLineMethod "setPopup" o = Poppler.AnnotMarkup.AnnotMarkupSetPopupMethodInfo + ResolveAnnotLineMethod "setPopupIsOpen" o = Poppler.AnnotMarkup.AnnotMarkupSetPopupIsOpenMethodInfo + ResolveAnnotLineMethod "setPopupRectangle" o = Poppler.AnnotMarkup.AnnotMarkupSetPopupRectangleMethodInfo + ResolveAnnotLineMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveAnnotLineMethod "setRectangle" o = Poppler.Annot.AnnotSetRectangleMethodInfo + ResolveAnnotLineMethod "setVertices" o = AnnotLineSetVerticesMethodInfo + ResolveAnnotLineMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveAnnotLineMethod t AnnotLine, O.MethodInfo info AnnotLine p) => OL.IsLabel t (AnnotLine -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList AnnotLine +type instance O.AttributeList AnnotLine = AnnotLineAttributeList +type AnnotLineAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList AnnotLine = AnnotLineSignalList +type AnnotLineSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method AnnotLine::new +-- method type : Constructor +-- Args : [Arg {argCName = "doc", argType = TInterface (Name {namespace = "Poppler", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rect", argType = TInterface (Name {namespace = "Poppler", name = "Rectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerRectangle", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start", argType = TInterface (Name {namespace = "Poppler", name = "Point"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerPoint of the starting vertice", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "end", argType = TInterface (Name {namespace = "Poppler", name = "Point"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerPoint of the ending vertice", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "AnnotLine"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_annot_line_new" poppler_annot_line_new :: + Ptr Poppler.Document.Document -> -- doc : TInterface (Name {namespace = "Poppler", name = "Document"}) + Ptr Poppler.Rectangle.Rectangle -> -- rect : TInterface (Name {namespace = "Poppler", name = "Rectangle"}) + Ptr Poppler.Point.Point -> -- start : TInterface (Name {namespace = "Poppler", name = "Point"}) + Ptr Poppler.Point.Point -> -- end : TInterface (Name {namespace = "Poppler", name = "Point"}) + IO (Ptr AnnotLine) + +{- | +Creates a new Line annotation that will be +located on /@rect@/ when added to a page. See +'GI.Poppler.Objects.Page.pageAddAnnot' + +/Since: 0.26/ +-} +annotLineNew :: + (B.CallStack.HasCallStack, MonadIO m, Poppler.Document.IsDocument a) => + a + {- ^ /@doc@/: a 'GI.Poppler.Objects.Document.Document' -} + -> Poppler.Rectangle.Rectangle + {- ^ /@rect@/: a 'GI.Poppler.Structs.Rectangle.Rectangle' -} + -> Poppler.Point.Point + {- ^ /@start@/: a 'GI.Poppler.Structs.Point.Point' of the starting vertice -} + -> Poppler.Point.Point + {- ^ /@end@/: a 'GI.Poppler.Structs.Point.Point' of the ending vertice -} + -> m AnnotLine + {- ^ __Returns:__ A newly created 'GI.Poppler.Objects.AnnotLine.AnnotLine' annotation -} +annotLineNew doc rect start end = liftIO $ do + doc' <- unsafeManagedPtrCastPtr doc + rect' <- unsafeManagedPtrGetPtr rect + start' <- unsafeManagedPtrGetPtr start + end' <- unsafeManagedPtrGetPtr end + result <- poppler_annot_line_new doc' rect' start' end' + checkUnexpectedReturnNULL "annotLineNew" result + result' <- (wrapObject AnnotLine) result + touchManagedPtr doc + touchManagedPtr rect + touchManagedPtr start + touchManagedPtr end + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method AnnotLine::set_vertices +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_annot", argType = TInterface (Name {namespace = "Poppler", name = "AnnotLine"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerAnnotLine", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start", argType = TInterface (Name {namespace = "Poppler", name = "Point"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerPoint of the starting vertice", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "end", argType = TInterface (Name {namespace = "Poppler", name = "Point"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerPoint of the ending vertice", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_annot_line_set_vertices" poppler_annot_line_set_vertices :: + Ptr AnnotLine -> -- poppler_annot : TInterface (Name {namespace = "Poppler", name = "AnnotLine"}) + Ptr Poppler.Point.Point -> -- start : TInterface (Name {namespace = "Poppler", name = "Point"}) + Ptr Poppler.Point.Point -> -- end : TInterface (Name {namespace = "Poppler", name = "Point"}) + IO () + +{- | +Set the coordinate points where the /@popplerAnnot@/ starts and ends. + +/Since: 0.26/ +-} +annotLineSetVertices :: + (B.CallStack.HasCallStack, MonadIO m, IsAnnotLine a) => + a + {- ^ /@popplerAnnot@/: a 'GI.Poppler.Objects.AnnotLine.AnnotLine' -} + -> Poppler.Point.Point + {- ^ /@start@/: a 'GI.Poppler.Structs.Point.Point' of the starting vertice -} + -> Poppler.Point.Point + {- ^ /@end@/: a 'GI.Poppler.Structs.Point.Point' of the ending vertice -} + -> m () +annotLineSetVertices popplerAnnot start end = liftIO $ do + popplerAnnot' <- unsafeManagedPtrCastPtr popplerAnnot + start' <- unsafeManagedPtrGetPtr start + end' <- unsafeManagedPtrGetPtr end + poppler_annot_line_set_vertices popplerAnnot' start' end' + touchManagedPtr popplerAnnot + touchManagedPtr start + touchManagedPtr end + return () + +#if ENABLE_OVERLOADING +data AnnotLineSetVerticesMethodInfo +instance (signature ~ (Poppler.Point.Point -> Poppler.Point.Point -> m ()), MonadIO m, IsAnnotLine a) => O.MethodInfo AnnotLineSetVerticesMethodInfo a signature where + overloadedMethod _ = annotLineSetVertices + +#endif + + 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,32 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Poppler.Objects.AnnotLine where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype AnnotLine = AnnotLine (ManagedPtr AnnotLine) +instance GObject AnnotLine where +class (GObject o, O.IsDescendantOf AnnotLine o) => IsAnnotLine o +instance (GObject o, O.IsDescendantOf AnnotLine o) => IsAnnotLine o +instance O.HasParentTypes AnnotLine +#if ENABLE_OVERLOADING +data AnnotLineSetVerticesMethodInfo +#endif 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,804 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Poppler.Objects.AnnotMarkup + ( + +-- * Exported types + AnnotMarkup(..) , + IsAnnotMarkup , + toAnnotMarkup , + noAnnotMarkup , + + + -- * Methods +-- ** getDate #method:getDate# + +#if ENABLE_OVERLOADING + AnnotMarkupGetDateMethodInfo , +#endif + annotMarkupGetDate , + + +-- ** getExternalData #method:getExternalData# + +#if ENABLE_OVERLOADING + AnnotMarkupGetExternalDataMethodInfo , +#endif + annotMarkupGetExternalData , + + +-- ** getLabel #method:getLabel# + +#if ENABLE_OVERLOADING + AnnotMarkupGetLabelMethodInfo , +#endif + annotMarkupGetLabel , + + +-- ** getOpacity #method:getOpacity# + +#if ENABLE_OVERLOADING + AnnotMarkupGetOpacityMethodInfo , +#endif + annotMarkupGetOpacity , + + +-- ** getPopupIsOpen #method:getPopupIsOpen# + +#if ENABLE_OVERLOADING + AnnotMarkupGetPopupIsOpenMethodInfo , +#endif + annotMarkupGetPopupIsOpen , + + +-- ** getPopupRectangle #method:getPopupRectangle# + +#if ENABLE_OVERLOADING + AnnotMarkupGetPopupRectangleMethodInfo , +#endif + annotMarkupGetPopupRectangle , + + +-- ** getReplyTo #method:getReplyTo# + +#if ENABLE_OVERLOADING + AnnotMarkupGetReplyToMethodInfo , +#endif + annotMarkupGetReplyTo , + + +-- ** getSubject #method:getSubject# + +#if ENABLE_OVERLOADING + AnnotMarkupGetSubjectMethodInfo , +#endif + annotMarkupGetSubject , + + +-- ** hasPopup #method:hasPopup# + +#if ENABLE_OVERLOADING + AnnotMarkupHasPopupMethodInfo , +#endif + annotMarkupHasPopup , + + +-- ** setLabel #method:setLabel# + +#if ENABLE_OVERLOADING + AnnotMarkupSetLabelMethodInfo , +#endif + annotMarkupSetLabel , + + +-- ** setOpacity #method:setOpacity# + +#if ENABLE_OVERLOADING + AnnotMarkupSetOpacityMethodInfo , +#endif + annotMarkupSetOpacity , + + +-- ** setPopup #method:setPopup# + +#if ENABLE_OVERLOADING + AnnotMarkupSetPopupMethodInfo , +#endif + annotMarkupSetPopup , + + +-- ** setPopupIsOpen #method:setPopupIsOpen# + +#if ENABLE_OVERLOADING + AnnotMarkupSetPopupIsOpenMethodInfo , +#endif + annotMarkupSetPopupIsOpen , + + +-- ** setPopupRectangle #method:setPopupRectangle# + +#if ENABLE_OVERLOADING + AnnotMarkupSetPopupRectangleMethodInfo , +#endif + annotMarkupSetPopupRectangle , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import qualified GI.GLib.Structs.Date as GLib.Date +import qualified GI.GObject.Objects.Object as GObject.Object +import {-# SOURCE #-} qualified GI.Poppler.Enums as Poppler.Enums +import {-# SOURCE #-} qualified GI.Poppler.Objects.Annot as Poppler.Annot +import {-# SOURCE #-} qualified GI.Poppler.Structs.Rectangle as Poppler.Rectangle + +-- | Memory-managed wrapper type. +newtype AnnotMarkup = AnnotMarkup (ManagedPtr AnnotMarkup) +foreign import ccall "poppler_annot_markup_get_type" + c_poppler_annot_markup_get_type :: IO GType + +instance GObject AnnotMarkup where + gobjectType = c_poppler_annot_markup_get_type + + +-- | Type class for types which can be safely cast to `AnnotMarkup`, for instance with `toAnnotMarkup`. +class (GObject o, O.IsDescendantOf AnnotMarkup o) => IsAnnotMarkup o +instance (GObject o, O.IsDescendantOf AnnotMarkup o) => IsAnnotMarkup o + +instance O.HasParentTypes AnnotMarkup +type instance O.ParentTypes AnnotMarkup = '[Poppler.Annot.Annot, GObject.Object.Object] + +-- | Cast to `AnnotMarkup`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toAnnotMarkup :: (MonadIO m, IsAnnotMarkup o) => o -> m AnnotMarkup +toAnnotMarkup = liftIO . unsafeCastTo AnnotMarkup + +-- | A convenience alias for `Nothing` :: `Maybe` `AnnotMarkup`. +noAnnotMarkup :: Maybe AnnotMarkup +noAnnotMarkup = Nothing + +#if ENABLE_OVERLOADING +type family ResolveAnnotMarkupMethod (t :: Symbol) (o :: *) :: * where + ResolveAnnotMarkupMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveAnnotMarkupMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveAnnotMarkupMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveAnnotMarkupMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveAnnotMarkupMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveAnnotMarkupMethod "hasPopup" o = AnnotMarkupHasPopupMethodInfo + ResolveAnnotMarkupMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveAnnotMarkupMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveAnnotMarkupMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveAnnotMarkupMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveAnnotMarkupMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveAnnotMarkupMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveAnnotMarkupMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveAnnotMarkupMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveAnnotMarkupMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveAnnotMarkupMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveAnnotMarkupMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveAnnotMarkupMethod "getAnnotType" o = Poppler.Annot.AnnotGetAnnotTypeMethodInfo + ResolveAnnotMarkupMethod "getColor" o = Poppler.Annot.AnnotGetColorMethodInfo + ResolveAnnotMarkupMethod "getContents" o = Poppler.Annot.AnnotGetContentsMethodInfo + ResolveAnnotMarkupMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveAnnotMarkupMethod "getDate" o = AnnotMarkupGetDateMethodInfo + ResolveAnnotMarkupMethod "getExternalData" o = AnnotMarkupGetExternalDataMethodInfo + ResolveAnnotMarkupMethod "getFlags" o = Poppler.Annot.AnnotGetFlagsMethodInfo + ResolveAnnotMarkupMethod "getLabel" o = AnnotMarkupGetLabelMethodInfo + ResolveAnnotMarkupMethod "getModified" o = Poppler.Annot.AnnotGetModifiedMethodInfo + ResolveAnnotMarkupMethod "getName" o = Poppler.Annot.AnnotGetNameMethodInfo + ResolveAnnotMarkupMethod "getOpacity" o = AnnotMarkupGetOpacityMethodInfo + ResolveAnnotMarkupMethod "getPageIndex" o = Poppler.Annot.AnnotGetPageIndexMethodInfo + ResolveAnnotMarkupMethod "getPopupIsOpen" o = AnnotMarkupGetPopupIsOpenMethodInfo + ResolveAnnotMarkupMethod "getPopupRectangle" o = AnnotMarkupGetPopupRectangleMethodInfo + ResolveAnnotMarkupMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveAnnotMarkupMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveAnnotMarkupMethod "getRectangle" o = Poppler.Annot.AnnotGetRectangleMethodInfo + ResolveAnnotMarkupMethod "getReplyTo" o = AnnotMarkupGetReplyToMethodInfo + ResolveAnnotMarkupMethod "getSubject" o = AnnotMarkupGetSubjectMethodInfo + ResolveAnnotMarkupMethod "setColor" o = Poppler.Annot.AnnotSetColorMethodInfo + ResolveAnnotMarkupMethod "setContents" o = Poppler.Annot.AnnotSetContentsMethodInfo + ResolveAnnotMarkupMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveAnnotMarkupMethod "setFlags" o = Poppler.Annot.AnnotSetFlagsMethodInfo + ResolveAnnotMarkupMethod "setLabel" o = AnnotMarkupSetLabelMethodInfo + ResolveAnnotMarkupMethod "setOpacity" o = AnnotMarkupSetOpacityMethodInfo + ResolveAnnotMarkupMethod "setPopup" o = AnnotMarkupSetPopupMethodInfo + ResolveAnnotMarkupMethod "setPopupIsOpen" o = AnnotMarkupSetPopupIsOpenMethodInfo + ResolveAnnotMarkupMethod "setPopupRectangle" o = AnnotMarkupSetPopupRectangleMethodInfo + ResolveAnnotMarkupMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveAnnotMarkupMethod "setRectangle" o = Poppler.Annot.AnnotSetRectangleMethodInfo + ResolveAnnotMarkupMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveAnnotMarkupMethod t AnnotMarkup, O.MethodInfo info AnnotMarkup p) => OL.IsLabel t (AnnotMarkup -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList AnnotMarkup +type instance O.AttributeList AnnotMarkup = AnnotMarkupAttributeList +type AnnotMarkupAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList AnnotMarkup = AnnotMarkupSignalList +type AnnotMarkupSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method AnnotMarkup::get_date +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_annot", argType = TInterface (Name {namespace = "Poppler", name = "AnnotMarkup"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerAnnotMarkup", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GLib", name = "Date"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_annot_markup_get_date" poppler_annot_markup_get_date :: + Ptr AnnotMarkup -> -- poppler_annot : TInterface (Name {namespace = "Poppler", name = "AnnotMarkup"}) + IO (Ptr GLib.Date.Date) + +{- | +Returns the date and time when the annotation was created +-} +annotMarkupGetDate :: + (B.CallStack.HasCallStack, MonadIO m, IsAnnotMarkup a) => + a + {- ^ /@popplerAnnot@/: a 'GI.Poppler.Objects.AnnotMarkup.AnnotMarkup' -} + -> m GLib.Date.Date + {- ^ __Returns:__ a 'GI.GLib.Structs.Date.Date' representing the date and time + when the annotation was created, or 'Nothing' -} +annotMarkupGetDate popplerAnnot = liftIO $ do + popplerAnnot' <- unsafeManagedPtrCastPtr popplerAnnot + result <- poppler_annot_markup_get_date popplerAnnot' + checkUnexpectedReturnNULL "annotMarkupGetDate" result + result' <- (wrapBoxed GLib.Date.Date) result + touchManagedPtr popplerAnnot + return result' + +#if ENABLE_OVERLOADING +data AnnotMarkupGetDateMethodInfo +instance (signature ~ (m GLib.Date.Date), MonadIO m, IsAnnotMarkup a) => O.MethodInfo AnnotMarkupGetDateMethodInfo a signature where + overloadedMethod _ = annotMarkupGetDate + +#endif + +-- method AnnotMarkup::get_external_data +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_annot", argType = TInterface (Name {namespace = "Poppler", name = "AnnotMarkup"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerAnnotMarkup", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "AnnotExternalDataType"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_annot_markup_get_external_data" poppler_annot_markup_get_external_data :: + Ptr AnnotMarkup -> -- poppler_annot : TInterface (Name {namespace = "Poppler", name = "AnnotMarkup"}) + IO CUInt + +{- | +Gets the external data type of /@popplerAnnot@/. +-} +annotMarkupGetExternalData :: + (B.CallStack.HasCallStack, MonadIO m, IsAnnotMarkup a) => + a + {- ^ /@popplerAnnot@/: a 'GI.Poppler.Objects.AnnotMarkup.AnnotMarkup' -} + -> m Poppler.Enums.AnnotExternalDataType + {- ^ __Returns:__ 'GI.Poppler.Enums.AnnotExternalDataType' of /@popplerAnnot@/. -} +annotMarkupGetExternalData popplerAnnot = liftIO $ do + popplerAnnot' <- unsafeManagedPtrCastPtr popplerAnnot + result <- poppler_annot_markup_get_external_data popplerAnnot' + let result' = (toEnum . fromIntegral) result + touchManagedPtr popplerAnnot + return result' + +#if ENABLE_OVERLOADING +data AnnotMarkupGetExternalDataMethodInfo +instance (signature ~ (m Poppler.Enums.AnnotExternalDataType), MonadIO m, IsAnnotMarkup a) => O.MethodInfo AnnotMarkupGetExternalDataMethodInfo a signature where + overloadedMethod _ = annotMarkupGetExternalData + +#endif + +-- method AnnotMarkup::get_label +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_annot", argType = TInterface (Name {namespace = "Poppler", name = "AnnotMarkup"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerAnnotMarkup", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_annot_markup_get_label" poppler_annot_markup_get_label :: + Ptr AnnotMarkup -> -- poppler_annot : TInterface (Name {namespace = "Poppler", name = "AnnotMarkup"}) + IO CString + +{- | +Retrieves the label text of /@popplerAnnot@/. +-} +annotMarkupGetLabel :: + (B.CallStack.HasCallStack, MonadIO m, IsAnnotMarkup a) => + a + {- ^ /@popplerAnnot@/: a 'GI.Poppler.Objects.AnnotMarkup.AnnotMarkup' -} + -> m T.Text + {- ^ __Returns:__ the label text of /@popplerAnnot@/. -} +annotMarkupGetLabel popplerAnnot = liftIO $ do + popplerAnnot' <- unsafeManagedPtrCastPtr popplerAnnot + result <- poppler_annot_markup_get_label popplerAnnot' + checkUnexpectedReturnNULL "annotMarkupGetLabel" result + result' <- cstringToText result + freeMem result + touchManagedPtr popplerAnnot + return result' + +#if ENABLE_OVERLOADING +data AnnotMarkupGetLabelMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsAnnotMarkup a) => O.MethodInfo AnnotMarkupGetLabelMethodInfo a signature where + overloadedMethod _ = annotMarkupGetLabel + +#endif + +-- method AnnotMarkup::get_opacity +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_annot", argType = TInterface (Name {namespace = "Poppler", name = "AnnotMarkup"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerAnnotMarkup", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TDouble) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_annot_markup_get_opacity" poppler_annot_markup_get_opacity :: + Ptr AnnotMarkup -> -- poppler_annot : TInterface (Name {namespace = "Poppler", name = "AnnotMarkup"}) + IO CDouble + +{- | +Retrieves the opacity value of /@popplerAnnot@/. +-} +annotMarkupGetOpacity :: + (B.CallStack.HasCallStack, MonadIO m, IsAnnotMarkup a) => + a + {- ^ /@popplerAnnot@/: a 'GI.Poppler.Objects.AnnotMarkup.AnnotMarkup' -} + -> m Double + {- ^ __Returns:__ the opacity value of /@popplerAnnot@/, + between 0 (transparent) and 1 (opaque) -} +annotMarkupGetOpacity popplerAnnot = liftIO $ do + popplerAnnot' <- unsafeManagedPtrCastPtr popplerAnnot + result <- poppler_annot_markup_get_opacity popplerAnnot' + let result' = realToFrac result + touchManagedPtr popplerAnnot + return result' + +#if ENABLE_OVERLOADING +data AnnotMarkupGetOpacityMethodInfo +instance (signature ~ (m Double), MonadIO m, IsAnnotMarkup a) => O.MethodInfo AnnotMarkupGetOpacityMethodInfo a signature where + overloadedMethod _ = annotMarkupGetOpacity + +#endif + +-- method AnnotMarkup::get_popup_is_open +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_annot", argType = TInterface (Name {namespace = "Poppler", name = "AnnotMarkup"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerAnnotMarkup", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_annot_markup_get_popup_is_open" poppler_annot_markup_get_popup_is_open :: + Ptr AnnotMarkup -> -- poppler_annot : TInterface (Name {namespace = "Poppler", name = "AnnotMarkup"}) + IO CInt + +{- | +Retrieves the state of the popup window related to /@popplerAnnot@/. +-} +annotMarkupGetPopupIsOpen :: + (B.CallStack.HasCallStack, MonadIO m, IsAnnotMarkup a) => + a + {- ^ /@popplerAnnot@/: a 'GI.Poppler.Objects.AnnotMarkup.AnnotMarkup' -} + -> m Bool + {- ^ __Returns:__ the state of /@popplerAnnot@/. 'True' if it\'s open, 'False' in + other case. -} +annotMarkupGetPopupIsOpen popplerAnnot = liftIO $ do + popplerAnnot' <- unsafeManagedPtrCastPtr popplerAnnot + result <- poppler_annot_markup_get_popup_is_open popplerAnnot' + let result' = (/= 0) result + touchManagedPtr popplerAnnot + return result' + +#if ENABLE_OVERLOADING +data AnnotMarkupGetPopupIsOpenMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsAnnotMarkup a) => O.MethodInfo AnnotMarkupGetPopupIsOpenMethodInfo a signature where + overloadedMethod _ = annotMarkupGetPopupIsOpen + +#endif + +-- method AnnotMarkup::get_popup_rectangle +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_annot", argType = TInterface (Name {namespace = "Poppler", name = "AnnotMarkup"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerAnnotMarkup", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "poppler_rect", argType = TInterface (Name {namespace = "Poppler", name = "Rectangle"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerRectangle to store the popup rectangle", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_annot_markup_get_popup_rectangle" poppler_annot_markup_get_popup_rectangle :: + Ptr AnnotMarkup -> -- poppler_annot : TInterface (Name {namespace = "Poppler", name = "AnnotMarkup"}) + Ptr Poppler.Rectangle.Rectangle -> -- poppler_rect : TInterface (Name {namespace = "Poppler", name = "Rectangle"}) + IO CInt + +{- | +Retrieves the rectangle of the popup window related to /@popplerAnnot@/. + +/Since: 0.12/ +-} +annotMarkupGetPopupRectangle :: + (B.CallStack.HasCallStack, MonadIO m, IsAnnotMarkup a) => + a + {- ^ /@popplerAnnot@/: a 'GI.Poppler.Objects.AnnotMarkup.AnnotMarkup' -} + -> m ((Bool, Poppler.Rectangle.Rectangle)) + {- ^ __Returns:__ 'True' if 'GI.Poppler.Structs.Rectangle.Rectangle' was correctly filled, 'False' otherwise -} +annotMarkupGetPopupRectangle popplerAnnot = liftIO $ do + popplerAnnot' <- unsafeManagedPtrCastPtr popplerAnnot + popplerRect <- callocBoxedBytes 32 :: IO (Ptr Poppler.Rectangle.Rectangle) + result <- poppler_annot_markup_get_popup_rectangle popplerAnnot' popplerRect + let result' = (/= 0) result + popplerRect' <- (wrapBoxed Poppler.Rectangle.Rectangle) popplerRect + touchManagedPtr popplerAnnot + return (result', popplerRect') + +#if ENABLE_OVERLOADING +data AnnotMarkupGetPopupRectangleMethodInfo +instance (signature ~ (m ((Bool, Poppler.Rectangle.Rectangle))), MonadIO m, IsAnnotMarkup a) => O.MethodInfo AnnotMarkupGetPopupRectangleMethodInfo a signature where + overloadedMethod _ = annotMarkupGetPopupRectangle + +#endif + +-- method AnnotMarkup::get_reply_to +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_annot", argType = TInterface (Name {namespace = "Poppler", name = "AnnotMarkup"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerAnnotMarkup", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "AnnotMarkupReplyType"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_annot_markup_get_reply_to" poppler_annot_markup_get_reply_to :: + Ptr AnnotMarkup -> -- poppler_annot : TInterface (Name {namespace = "Poppler", name = "AnnotMarkup"}) + IO CUInt + +{- | +Gets the reply type of /@popplerAnnot@/. +-} +annotMarkupGetReplyTo :: + (B.CallStack.HasCallStack, MonadIO m, IsAnnotMarkup a) => + a + {- ^ /@popplerAnnot@/: a 'GI.Poppler.Objects.AnnotMarkup.AnnotMarkup' -} + -> m Poppler.Enums.AnnotMarkupReplyType + {- ^ __Returns:__ 'GI.Poppler.Enums.AnnotMarkupReplyType' of /@popplerAnnot@/. -} +annotMarkupGetReplyTo popplerAnnot = liftIO $ do + popplerAnnot' <- unsafeManagedPtrCastPtr popplerAnnot + result <- poppler_annot_markup_get_reply_to popplerAnnot' + let result' = (toEnum . fromIntegral) result + touchManagedPtr popplerAnnot + return result' + +#if ENABLE_OVERLOADING +data AnnotMarkupGetReplyToMethodInfo +instance (signature ~ (m Poppler.Enums.AnnotMarkupReplyType), MonadIO m, IsAnnotMarkup a) => O.MethodInfo AnnotMarkupGetReplyToMethodInfo a signature where + overloadedMethod _ = annotMarkupGetReplyTo + +#endif + +-- method AnnotMarkup::get_subject +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_annot", argType = TInterface (Name {namespace = "Poppler", name = "AnnotMarkup"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerAnnotMarkup", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_annot_markup_get_subject" poppler_annot_markup_get_subject :: + Ptr AnnotMarkup -> -- poppler_annot : TInterface (Name {namespace = "Poppler", name = "AnnotMarkup"}) + IO CString + +{- | +Retrives the subject text of /@popplerAnnot@/. +-} +annotMarkupGetSubject :: + (B.CallStack.HasCallStack, MonadIO m, IsAnnotMarkup a) => + a + {- ^ /@popplerAnnot@/: a 'GI.Poppler.Objects.AnnotMarkup.AnnotMarkup' -} + -> m T.Text + {- ^ __Returns:__ the subject text of /@popplerAnnot@/. -} +annotMarkupGetSubject popplerAnnot = liftIO $ do + popplerAnnot' <- unsafeManagedPtrCastPtr popplerAnnot + result <- poppler_annot_markup_get_subject popplerAnnot' + checkUnexpectedReturnNULL "annotMarkupGetSubject" result + result' <- cstringToText result + freeMem result + touchManagedPtr popplerAnnot + return result' + +#if ENABLE_OVERLOADING +data AnnotMarkupGetSubjectMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsAnnotMarkup a) => O.MethodInfo AnnotMarkupGetSubjectMethodInfo a signature where + overloadedMethod _ = annotMarkupGetSubject + +#endif + +-- method AnnotMarkup::has_popup +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_annot", argType = TInterface (Name {namespace = "Poppler", name = "AnnotMarkup"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerAnnotMarkup", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_annot_markup_has_popup" poppler_annot_markup_has_popup :: + Ptr AnnotMarkup -> -- poppler_annot : TInterface (Name {namespace = "Poppler", name = "AnnotMarkup"}) + IO CInt + +{- | +Return 'True' if the markup annotation has a popup window associated + +/Since: 0.12/ +-} +annotMarkupHasPopup :: + (B.CallStack.HasCallStack, MonadIO m, IsAnnotMarkup a) => + a + {- ^ /@popplerAnnot@/: a 'GI.Poppler.Objects.AnnotMarkup.AnnotMarkup' -} + -> m Bool + {- ^ __Returns:__ 'True', if /@popplerAnnot@/ has popup, 'False' otherwise -} +annotMarkupHasPopup popplerAnnot = liftIO $ do + popplerAnnot' <- unsafeManagedPtrCastPtr popplerAnnot + result <- poppler_annot_markup_has_popup popplerAnnot' + let result' = (/= 0) result + touchManagedPtr popplerAnnot + return result' + +#if ENABLE_OVERLOADING +data AnnotMarkupHasPopupMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsAnnotMarkup a) => O.MethodInfo AnnotMarkupHasPopupMethodInfo a signature where + overloadedMethod _ = annotMarkupHasPopup + +#endif + +-- method AnnotMarkup::set_label +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_annot", argType = TInterface (Name {namespace = "Poppler", name = "AnnotMarkup"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerAnnotMarkup", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a text string containing the new label, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_annot_markup_set_label" poppler_annot_markup_set_label :: + Ptr AnnotMarkup -> -- poppler_annot : TInterface (Name {namespace = "Poppler", name = "AnnotMarkup"}) + CString -> -- label : TBasicType TUTF8 + IO () + +{- | +Sets the label text of /@popplerAnnot@/, replacing the current one + +/Since: 0.16/ +-} +annotMarkupSetLabel :: + (B.CallStack.HasCallStack, MonadIO m, IsAnnotMarkup a) => + a + {- ^ /@popplerAnnot@/: a 'GI.Poppler.Objects.AnnotMarkup.AnnotMarkup' -} + -> Maybe (T.Text) + {- ^ /@label@/: a text string containing the new label, or 'Nothing' -} + -> m () +annotMarkupSetLabel popplerAnnot label = liftIO $ do + popplerAnnot' <- unsafeManagedPtrCastPtr popplerAnnot + maybeLabel <- case label of + Nothing -> return nullPtr + Just jLabel -> do + jLabel' <- textToCString jLabel + return jLabel' + poppler_annot_markup_set_label popplerAnnot' maybeLabel + touchManagedPtr popplerAnnot + freeMem maybeLabel + return () + +#if ENABLE_OVERLOADING +data AnnotMarkupSetLabelMethodInfo +instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsAnnotMarkup a) => O.MethodInfo AnnotMarkupSetLabelMethodInfo a signature where + overloadedMethod _ = annotMarkupSetLabel + +#endif + +-- method AnnotMarkup::set_opacity +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_annot", argType = TInterface (Name {namespace = "Poppler", name = "AnnotMarkup"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerAnnotMarkup", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "opacity", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a constant opacity value, between 0 (transparent) and 1 (opaque)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_annot_markup_set_opacity" poppler_annot_markup_set_opacity :: + Ptr AnnotMarkup -> -- poppler_annot : TInterface (Name {namespace = "Poppler", name = "AnnotMarkup"}) + CDouble -> -- opacity : TBasicType TDouble + IO () + +{- | +Sets the opacity of /@popplerAnnot@/. This value applies to +all visible elements of /@popplerAnnot@/ in its closed state, +but not to the pop-up window that appears when it\'s openened + +/Since: 0.16/ +-} +annotMarkupSetOpacity :: + (B.CallStack.HasCallStack, MonadIO m, IsAnnotMarkup a) => + a + {- ^ /@popplerAnnot@/: a 'GI.Poppler.Objects.AnnotMarkup.AnnotMarkup' -} + -> Double + {- ^ /@opacity@/: a constant opacity value, between 0 (transparent) and 1 (opaque) -} + -> m () +annotMarkupSetOpacity popplerAnnot opacity = liftIO $ do + popplerAnnot' <- unsafeManagedPtrCastPtr popplerAnnot + let opacity' = realToFrac opacity + poppler_annot_markup_set_opacity popplerAnnot' opacity' + touchManagedPtr popplerAnnot + return () + +#if ENABLE_OVERLOADING +data AnnotMarkupSetOpacityMethodInfo +instance (signature ~ (Double -> m ()), MonadIO m, IsAnnotMarkup a) => O.MethodInfo AnnotMarkupSetOpacityMethodInfo a signature where + overloadedMethod _ = annotMarkupSetOpacity + +#endif + +-- method AnnotMarkup::set_popup +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_annot", argType = TInterface (Name {namespace = "Poppler", name = "AnnotMarkup"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerAnnotMarkup", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "popup_rect", argType = TInterface (Name {namespace = "Poppler", name = "Rectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerRectangle", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_annot_markup_set_popup" poppler_annot_markup_set_popup :: + Ptr AnnotMarkup -> -- poppler_annot : TInterface (Name {namespace = "Poppler", name = "AnnotMarkup"}) + Ptr Poppler.Rectangle.Rectangle -> -- popup_rect : TInterface (Name {namespace = "Poppler", name = "Rectangle"}) + IO () + +{- | +Associates a new popup window for editing contents of /@popplerAnnot@/. +Popup window shall be displayed by viewers at /@popupRect@/ on the page. + +/Since: 0.16/ +-} +annotMarkupSetPopup :: + (B.CallStack.HasCallStack, MonadIO m, IsAnnotMarkup a) => + a + {- ^ /@popplerAnnot@/: a 'GI.Poppler.Objects.AnnotMarkup.AnnotMarkup' -} + -> Poppler.Rectangle.Rectangle + {- ^ /@popupRect@/: a 'GI.Poppler.Structs.Rectangle.Rectangle' -} + -> m () +annotMarkupSetPopup popplerAnnot popupRect = liftIO $ do + popplerAnnot' <- unsafeManagedPtrCastPtr popplerAnnot + popupRect' <- unsafeManagedPtrGetPtr popupRect + poppler_annot_markup_set_popup popplerAnnot' popupRect' + touchManagedPtr popplerAnnot + touchManagedPtr popupRect + return () + +#if ENABLE_OVERLOADING +data AnnotMarkupSetPopupMethodInfo +instance (signature ~ (Poppler.Rectangle.Rectangle -> m ()), MonadIO m, IsAnnotMarkup a) => O.MethodInfo AnnotMarkupSetPopupMethodInfo a signature where + overloadedMethod _ = annotMarkupSetPopup + +#endif + +-- method AnnotMarkup::set_popup_is_open +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_annot", argType = TInterface (Name {namespace = "Poppler", name = "AnnotMarkup"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerAnnotMarkup", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "is_open", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether popup window should initially be displayed open", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_annot_markup_set_popup_is_open" poppler_annot_markup_set_popup_is_open :: + Ptr AnnotMarkup -> -- poppler_annot : TInterface (Name {namespace = "Poppler", name = "AnnotMarkup"}) + CInt -> -- is_open : TBasicType TBoolean + IO () + +{- | +Sets the state of the popup window related to /@popplerAnnot@/. + +/Since: 0.16/ +-} +annotMarkupSetPopupIsOpen :: + (B.CallStack.HasCallStack, MonadIO m, IsAnnotMarkup a) => + a + {- ^ /@popplerAnnot@/: a 'GI.Poppler.Objects.AnnotMarkup.AnnotMarkup' -} + -> Bool + {- ^ /@isOpen@/: whether popup window should initially be displayed open -} + -> m () +annotMarkupSetPopupIsOpen popplerAnnot isOpen = liftIO $ do + popplerAnnot' <- unsafeManagedPtrCastPtr popplerAnnot + let isOpen' = (fromIntegral . fromEnum) isOpen + poppler_annot_markup_set_popup_is_open popplerAnnot' isOpen' + touchManagedPtr popplerAnnot + return () + +#if ENABLE_OVERLOADING +data AnnotMarkupSetPopupIsOpenMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsAnnotMarkup a) => O.MethodInfo AnnotMarkupSetPopupIsOpenMethodInfo a signature where + overloadedMethod _ = annotMarkupSetPopupIsOpen + +#endif + +-- method AnnotMarkup::set_popup_rectangle +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_annot", argType = TInterface (Name {namespace = "Poppler", name = "AnnotMarkup"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerAnnotMarkup", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "poppler_rect", argType = TInterface (Name {namespace = "Poppler", name = "Rectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerRectangle to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_annot_markup_set_popup_rectangle" poppler_annot_markup_set_popup_rectangle :: + Ptr AnnotMarkup -> -- poppler_annot : TInterface (Name {namespace = "Poppler", name = "AnnotMarkup"}) + Ptr Poppler.Rectangle.Rectangle -> -- poppler_rect : TInterface (Name {namespace = "Poppler", name = "Rectangle"}) + IO () + +{- | +Sets the rectangle of the popup window related to /@popplerAnnot@/. +This doesn\'t have any effect if /@popplerAnnot@/ doesn\'t have a +popup associated, use 'GI.Poppler.Objects.AnnotMarkup.annotMarkupSetPopup' to associate +a popup window to a 'GI.Poppler.Objects.AnnotMarkup.AnnotMarkup'. + +/Since: 0.33/ +-} +annotMarkupSetPopupRectangle :: + (B.CallStack.HasCallStack, MonadIO m, IsAnnotMarkup a) => + a + {- ^ /@popplerAnnot@/: a 'GI.Poppler.Objects.AnnotMarkup.AnnotMarkup' -} + -> Poppler.Rectangle.Rectangle + {- ^ /@popplerRect@/: a 'GI.Poppler.Structs.Rectangle.Rectangle' to set -} + -> m () +annotMarkupSetPopupRectangle popplerAnnot popplerRect = liftIO $ do + popplerAnnot' <- unsafeManagedPtrCastPtr popplerAnnot + popplerRect' <- unsafeManagedPtrGetPtr popplerRect + poppler_annot_markup_set_popup_rectangle popplerAnnot' popplerRect' + touchManagedPtr popplerAnnot + touchManagedPtr popplerRect + return () + +#if ENABLE_OVERLOADING +data AnnotMarkupSetPopupRectangleMethodInfo +instance (signature ~ (Poppler.Rectangle.Rectangle -> m ()), MonadIO m, IsAnnotMarkup a) => O.MethodInfo AnnotMarkupSetPopupRectangleMethodInfo a signature where + overloadedMethod _ = annotMarkupSetPopupRectangle + +#endif + + 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,71 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Poppler.Objects.AnnotMarkup where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype AnnotMarkup = AnnotMarkup (ManagedPtr AnnotMarkup) +instance GObject AnnotMarkup where +class (GObject o, O.IsDescendantOf AnnotMarkup o) => IsAnnotMarkup o +instance (GObject o, O.IsDescendantOf AnnotMarkup o) => IsAnnotMarkup o +instance O.HasParentTypes AnnotMarkup +#if ENABLE_OVERLOADING +data AnnotMarkupGetDateMethodInfo +#endif +#if ENABLE_OVERLOADING +data AnnotMarkupGetExternalDataMethodInfo +#endif +#if ENABLE_OVERLOADING +data AnnotMarkupGetLabelMethodInfo +#endif +#if ENABLE_OVERLOADING +data AnnotMarkupGetOpacityMethodInfo +#endif +#if ENABLE_OVERLOADING +data AnnotMarkupGetPopupIsOpenMethodInfo +#endif +#if ENABLE_OVERLOADING +data AnnotMarkupGetPopupRectangleMethodInfo +#endif +#if ENABLE_OVERLOADING +data AnnotMarkupGetReplyToMethodInfo +#endif +#if ENABLE_OVERLOADING +data AnnotMarkupGetSubjectMethodInfo +#endif +#if ENABLE_OVERLOADING +data AnnotMarkupHasPopupMethodInfo +#endif +#if ENABLE_OVERLOADING +data AnnotMarkupSetLabelMethodInfo +#endif +#if ENABLE_OVERLOADING +data AnnotMarkupSetOpacityMethodInfo +#endif +#if ENABLE_OVERLOADING +data AnnotMarkupSetPopupMethodInfo +#endif +#if ENABLE_OVERLOADING +data AnnotMarkupSetPopupIsOpenMethodInfo +#endif +#if ENABLE_OVERLOADING +data AnnotMarkupSetPopupRectangleMethodInfo +#endif 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,234 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Poppler.Objects.AnnotMovie + ( + +-- * Exported types + AnnotMovie(..) , + IsAnnotMovie , + toAnnotMovie , + noAnnotMovie , + + + -- * Methods +-- ** getMovie #method:getMovie# + +#if ENABLE_OVERLOADING + AnnotMovieGetMovieMethodInfo , +#endif + annotMovieGetMovie , + + +-- ** getTitle #method:getTitle# + +#if ENABLE_OVERLOADING + AnnotMovieGetTitleMethodInfo , +#endif + annotMovieGetTitle , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import qualified GI.GObject.Objects.Object as GObject.Object +import {-# SOURCE #-} qualified GI.Poppler.Objects.Annot as Poppler.Annot +import {-# SOURCE #-} qualified GI.Poppler.Objects.Movie as Poppler.Movie + +-- | Memory-managed wrapper type. +newtype AnnotMovie = AnnotMovie (ManagedPtr AnnotMovie) +foreign import ccall "poppler_annot_movie_get_type" + c_poppler_annot_movie_get_type :: IO GType + +instance GObject AnnotMovie where + gobjectType = c_poppler_annot_movie_get_type + + +-- | Type class for types which can be safely cast to `AnnotMovie`, for instance with `toAnnotMovie`. +class (GObject o, O.IsDescendantOf AnnotMovie o) => IsAnnotMovie o +instance (GObject o, O.IsDescendantOf AnnotMovie o) => IsAnnotMovie o + +instance O.HasParentTypes AnnotMovie +type instance O.ParentTypes AnnotMovie = '[Poppler.Annot.Annot, GObject.Object.Object] + +-- | Cast to `AnnotMovie`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toAnnotMovie :: (MonadIO m, IsAnnotMovie o) => o -> m AnnotMovie +toAnnotMovie = liftIO . unsafeCastTo AnnotMovie + +-- | A convenience alias for `Nothing` :: `Maybe` `AnnotMovie`. +noAnnotMovie :: Maybe AnnotMovie +noAnnotMovie = Nothing + +#if ENABLE_OVERLOADING +type family ResolveAnnotMovieMethod (t :: Symbol) (o :: *) :: * where + ResolveAnnotMovieMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveAnnotMovieMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveAnnotMovieMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveAnnotMovieMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveAnnotMovieMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveAnnotMovieMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveAnnotMovieMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveAnnotMovieMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveAnnotMovieMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveAnnotMovieMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveAnnotMovieMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveAnnotMovieMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveAnnotMovieMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveAnnotMovieMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveAnnotMovieMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveAnnotMovieMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveAnnotMovieMethod "getAnnotType" o = Poppler.Annot.AnnotGetAnnotTypeMethodInfo + ResolveAnnotMovieMethod "getColor" o = Poppler.Annot.AnnotGetColorMethodInfo + ResolveAnnotMovieMethod "getContents" o = Poppler.Annot.AnnotGetContentsMethodInfo + ResolveAnnotMovieMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveAnnotMovieMethod "getFlags" o = Poppler.Annot.AnnotGetFlagsMethodInfo + ResolveAnnotMovieMethod "getModified" o = Poppler.Annot.AnnotGetModifiedMethodInfo + ResolveAnnotMovieMethod "getMovie" o = AnnotMovieGetMovieMethodInfo + ResolveAnnotMovieMethod "getName" o = Poppler.Annot.AnnotGetNameMethodInfo + ResolveAnnotMovieMethod "getPageIndex" o = Poppler.Annot.AnnotGetPageIndexMethodInfo + ResolveAnnotMovieMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveAnnotMovieMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveAnnotMovieMethod "getRectangle" o = Poppler.Annot.AnnotGetRectangleMethodInfo + ResolveAnnotMovieMethod "getTitle" o = AnnotMovieGetTitleMethodInfo + ResolveAnnotMovieMethod "setColor" o = Poppler.Annot.AnnotSetColorMethodInfo + ResolveAnnotMovieMethod "setContents" o = Poppler.Annot.AnnotSetContentsMethodInfo + ResolveAnnotMovieMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveAnnotMovieMethod "setFlags" o = Poppler.Annot.AnnotSetFlagsMethodInfo + ResolveAnnotMovieMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveAnnotMovieMethod "setRectangle" o = Poppler.Annot.AnnotSetRectangleMethodInfo + ResolveAnnotMovieMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveAnnotMovieMethod t AnnotMovie, O.MethodInfo info AnnotMovie p) => OL.IsLabel t (AnnotMovie -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList AnnotMovie +type instance O.AttributeList AnnotMovie = AnnotMovieAttributeList +type AnnotMovieAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList AnnotMovie = AnnotMovieSignalList +type AnnotMovieSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method AnnotMovie::get_movie +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_annot", argType = TInterface (Name {namespace = "Poppler", name = "AnnotMovie"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerAnnotMovie", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "Movie"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_annot_movie_get_movie" poppler_annot_movie_get_movie :: + Ptr AnnotMovie -> -- poppler_annot : TInterface (Name {namespace = "Poppler", name = "AnnotMovie"}) + IO (Ptr Poppler.Movie.Movie) + +{- | +Retrieves the movie object (PopplerMovie) stored in the /@popplerAnnot@/. + +/Since: 0.14/ +-} +annotMovieGetMovie :: + (B.CallStack.HasCallStack, MonadIO m, IsAnnotMovie a) => + a + {- ^ /@popplerAnnot@/: a 'GI.Poppler.Objects.AnnotMovie.AnnotMovie' -} + -> m Poppler.Movie.Movie + {- ^ __Returns:__ the movie object stored in the /@popplerAnnot@/. The returned + object is owned by 'GI.Poppler.Objects.AnnotMovie.AnnotMovie' and should not be freed -} +annotMovieGetMovie popplerAnnot = liftIO $ do + popplerAnnot' <- unsafeManagedPtrCastPtr popplerAnnot + result <- poppler_annot_movie_get_movie popplerAnnot' + checkUnexpectedReturnNULL "annotMovieGetMovie" result + result' <- (newObject Poppler.Movie.Movie) result + touchManagedPtr popplerAnnot + return result' + +#if ENABLE_OVERLOADING +data AnnotMovieGetMovieMethodInfo +instance (signature ~ (m Poppler.Movie.Movie), MonadIO m, IsAnnotMovie a) => O.MethodInfo AnnotMovieGetMovieMethodInfo a signature where + overloadedMethod _ = annotMovieGetMovie + +#endif + +-- method AnnotMovie::get_title +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_annot", argType = TInterface (Name {namespace = "Poppler", name = "AnnotMovie"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerAnnotMovie", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_annot_movie_get_title" poppler_annot_movie_get_title :: + Ptr AnnotMovie -> -- poppler_annot : TInterface (Name {namespace = "Poppler", name = "AnnotMovie"}) + IO CString + +{- | +Retrieves the movie title of /@popplerAnnot@/. + +/Since: 0.14/ +-} +annotMovieGetTitle :: + (B.CallStack.HasCallStack, MonadIO m, IsAnnotMovie a) => + a + {- ^ /@popplerAnnot@/: a 'GI.Poppler.Objects.AnnotMovie.AnnotMovie' -} + -> m T.Text + {- ^ __Returns:__ the title text of /@popplerAnnot@/. -} +annotMovieGetTitle popplerAnnot = liftIO $ do + popplerAnnot' <- unsafeManagedPtrCastPtr popplerAnnot + result <- poppler_annot_movie_get_title popplerAnnot' + checkUnexpectedReturnNULL "annotMovieGetTitle" result + result' <- cstringToText result + freeMem result + touchManagedPtr popplerAnnot + return result' + +#if ENABLE_OVERLOADING +data AnnotMovieGetTitleMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsAnnotMovie a) => O.MethodInfo AnnotMovieGetTitleMethodInfo a signature where + overloadedMethod _ = annotMovieGetTitle + +#endif + + 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,35 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Poppler.Objects.AnnotMovie where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype AnnotMovie = AnnotMovie (ManagedPtr AnnotMovie) +instance GObject AnnotMovie where +class (GObject o, O.IsDescendantOf AnnotMovie o) => IsAnnotMovie o +instance (GObject o, O.IsDescendantOf AnnotMovie o) => IsAnnotMovie o +instance O.HasParentTypes AnnotMovie +#if ENABLE_OVERLOADING +data AnnotMovieGetMovieMethodInfo +#endif +#if ENABLE_OVERLOADING +data AnnotMovieGetTitleMethodInfo +#endif 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,186 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Poppler.Objects.AnnotScreen + ( + +-- * Exported types + AnnotScreen(..) , + IsAnnotScreen , + toAnnotScreen , + noAnnotScreen , + + + -- * Methods +-- ** getAction #method:getAction# + +#if ENABLE_OVERLOADING + AnnotScreenGetActionMethodInfo , +#endif + annotScreenGetAction , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import qualified GI.GObject.Objects.Object as GObject.Object +import {-# SOURCE #-} qualified GI.Poppler.Objects.Annot as Poppler.Annot +import {-# SOURCE #-} qualified GI.Poppler.Unions.Action as Poppler.Action + +-- | Memory-managed wrapper type. +newtype AnnotScreen = AnnotScreen (ManagedPtr AnnotScreen) +foreign import ccall "poppler_annot_screen_get_type" + c_poppler_annot_screen_get_type :: IO GType + +instance GObject AnnotScreen where + gobjectType = c_poppler_annot_screen_get_type + + +-- | Type class for types which can be safely cast to `AnnotScreen`, for instance with `toAnnotScreen`. +class (GObject o, O.IsDescendantOf AnnotScreen o) => IsAnnotScreen o +instance (GObject o, O.IsDescendantOf AnnotScreen o) => IsAnnotScreen o + +instance O.HasParentTypes AnnotScreen +type instance O.ParentTypes AnnotScreen = '[Poppler.Annot.Annot, GObject.Object.Object] + +-- | Cast to `AnnotScreen`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toAnnotScreen :: (MonadIO m, IsAnnotScreen o) => o -> m AnnotScreen +toAnnotScreen = liftIO . unsafeCastTo AnnotScreen + +-- | A convenience alias for `Nothing` :: `Maybe` `AnnotScreen`. +noAnnotScreen :: Maybe AnnotScreen +noAnnotScreen = Nothing + +#if ENABLE_OVERLOADING +type family ResolveAnnotScreenMethod (t :: Symbol) (o :: *) :: * where + ResolveAnnotScreenMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveAnnotScreenMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveAnnotScreenMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveAnnotScreenMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveAnnotScreenMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveAnnotScreenMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveAnnotScreenMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveAnnotScreenMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveAnnotScreenMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveAnnotScreenMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveAnnotScreenMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveAnnotScreenMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveAnnotScreenMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveAnnotScreenMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveAnnotScreenMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveAnnotScreenMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveAnnotScreenMethod "getAction" o = AnnotScreenGetActionMethodInfo + ResolveAnnotScreenMethod "getAnnotType" o = Poppler.Annot.AnnotGetAnnotTypeMethodInfo + ResolveAnnotScreenMethod "getColor" o = Poppler.Annot.AnnotGetColorMethodInfo + ResolveAnnotScreenMethod "getContents" o = Poppler.Annot.AnnotGetContentsMethodInfo + ResolveAnnotScreenMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveAnnotScreenMethod "getFlags" o = Poppler.Annot.AnnotGetFlagsMethodInfo + ResolveAnnotScreenMethod "getModified" o = Poppler.Annot.AnnotGetModifiedMethodInfo + ResolveAnnotScreenMethod "getName" o = Poppler.Annot.AnnotGetNameMethodInfo + ResolveAnnotScreenMethod "getPageIndex" o = Poppler.Annot.AnnotGetPageIndexMethodInfo + ResolveAnnotScreenMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveAnnotScreenMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveAnnotScreenMethod "getRectangle" o = Poppler.Annot.AnnotGetRectangleMethodInfo + ResolveAnnotScreenMethod "setColor" o = Poppler.Annot.AnnotSetColorMethodInfo + ResolveAnnotScreenMethod "setContents" o = Poppler.Annot.AnnotSetContentsMethodInfo + ResolveAnnotScreenMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveAnnotScreenMethod "setFlags" o = Poppler.Annot.AnnotSetFlagsMethodInfo + ResolveAnnotScreenMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveAnnotScreenMethod "setRectangle" o = Poppler.Annot.AnnotSetRectangleMethodInfo + ResolveAnnotScreenMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveAnnotScreenMethod t AnnotScreen, O.MethodInfo info AnnotScreen p) => OL.IsLabel t (AnnotScreen -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList AnnotScreen +type instance O.AttributeList AnnotScreen = AnnotScreenAttributeList +type AnnotScreenAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList AnnotScreen = AnnotScreenSignalList +type AnnotScreenSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method AnnotScreen::get_action +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_annot", argType = TInterface (Name {namespace = "Poppler", name = "AnnotScreen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerAnnotScreen", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "Action"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_annot_screen_get_action" poppler_annot_screen_get_action :: + Ptr AnnotScreen -> -- poppler_annot : TInterface (Name {namespace = "Poppler", name = "AnnotScreen"}) + IO (Ptr Poppler.Action.Action) + +{- | +Retrieves the action ('GI.Poppler.Unions.Action.Action') that shall be performed when /@popplerAnnot@/ is activated + +/Since: 0.14/ +-} +annotScreenGetAction :: + (B.CallStack.HasCallStack, MonadIO m, IsAnnotScreen a) => + a + {- ^ /@popplerAnnot@/: a 'GI.Poppler.Objects.AnnotScreen.AnnotScreen' -} + -> m Poppler.Action.Action + {- ^ __Returns:__ the action to perform. The returned + object is owned by /@popplerAnnot@/ and should not be freed -} +annotScreenGetAction popplerAnnot = liftIO $ do + popplerAnnot' <- unsafeManagedPtrCastPtr popplerAnnot + result <- poppler_annot_screen_get_action popplerAnnot' + checkUnexpectedReturnNULL "annotScreenGetAction" result + result' <- (newBoxed Poppler.Action.Action) result + touchManagedPtr popplerAnnot + return result' + +#if ENABLE_OVERLOADING +data AnnotScreenGetActionMethodInfo +instance (signature ~ (m Poppler.Action.Action), MonadIO m, IsAnnotScreen a) => O.MethodInfo AnnotScreenGetActionMethodInfo a signature where + overloadedMethod _ = annotScreenGetAction + +#endif + + 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,32 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Poppler.Objects.AnnotScreen where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype AnnotScreen = AnnotScreen (ManagedPtr AnnotScreen) +instance GObject AnnotScreen where +class (GObject o, O.IsDescendantOf AnnotScreen o) => IsAnnotScreen o +instance (GObject o, O.IsDescendantOf AnnotScreen o) => IsAnnotScreen o +instance O.HasParentTypes AnnotScreen +#if ENABLE_OVERLOADING +data AnnotScreenGetActionMethodInfo +#endif 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,302 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Poppler.Objects.AnnotSquare + ( + +-- * Exported types + AnnotSquare(..) , + IsAnnotSquare , + toAnnotSquare , + noAnnotSquare , + + + -- * Methods +-- ** getInteriorColor #method:getInteriorColor# + +#if ENABLE_OVERLOADING + AnnotSquareGetInteriorColorMethodInfo , +#endif + annotSquareGetInteriorColor , + + +-- ** new #method:new# + + annotSquareNew , + + +-- ** setInteriorColor #method:setInteriorColor# + +#if ENABLE_OVERLOADING + AnnotSquareSetInteriorColorMethodInfo , +#endif + annotSquareSetInteriorColor , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import qualified GI.GObject.Objects.Object as GObject.Object +import {-# SOURCE #-} qualified GI.Poppler.Objects.Annot as Poppler.Annot +import {-# SOURCE #-} qualified GI.Poppler.Objects.AnnotMarkup as Poppler.AnnotMarkup +import {-# SOURCE #-} qualified GI.Poppler.Objects.Document as Poppler.Document +import {-# SOURCE #-} qualified GI.Poppler.Structs.Color as Poppler.Color +import {-# SOURCE #-} qualified GI.Poppler.Structs.Rectangle as Poppler.Rectangle + +-- | Memory-managed wrapper type. +newtype AnnotSquare = AnnotSquare (ManagedPtr AnnotSquare) +foreign import ccall "poppler_annot_square_get_type" + c_poppler_annot_square_get_type :: IO GType + +instance GObject AnnotSquare where + gobjectType = c_poppler_annot_square_get_type + + +-- | Type class for types which can be safely cast to `AnnotSquare`, for instance with `toAnnotSquare`. +class (GObject o, O.IsDescendantOf AnnotSquare o) => IsAnnotSquare o +instance (GObject o, O.IsDescendantOf AnnotSquare o) => IsAnnotSquare o + +instance O.HasParentTypes AnnotSquare +type instance O.ParentTypes AnnotSquare = '[Poppler.AnnotMarkup.AnnotMarkup, Poppler.Annot.Annot, GObject.Object.Object] + +-- | Cast to `AnnotSquare`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toAnnotSquare :: (MonadIO m, IsAnnotSquare o) => o -> m AnnotSquare +toAnnotSquare = liftIO . unsafeCastTo AnnotSquare + +-- | A convenience alias for `Nothing` :: `Maybe` `AnnotSquare`. +noAnnotSquare :: Maybe AnnotSquare +noAnnotSquare = Nothing + +#if ENABLE_OVERLOADING +type family ResolveAnnotSquareMethod (t :: Symbol) (o :: *) :: * where + ResolveAnnotSquareMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveAnnotSquareMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveAnnotSquareMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveAnnotSquareMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveAnnotSquareMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveAnnotSquareMethod "hasPopup" o = Poppler.AnnotMarkup.AnnotMarkupHasPopupMethodInfo + ResolveAnnotSquareMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveAnnotSquareMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveAnnotSquareMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveAnnotSquareMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveAnnotSquareMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveAnnotSquareMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveAnnotSquareMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveAnnotSquareMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveAnnotSquareMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveAnnotSquareMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveAnnotSquareMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveAnnotSquareMethod "getAnnotType" o = Poppler.Annot.AnnotGetAnnotTypeMethodInfo + ResolveAnnotSquareMethod "getColor" o = Poppler.Annot.AnnotGetColorMethodInfo + ResolveAnnotSquareMethod "getContents" o = Poppler.Annot.AnnotGetContentsMethodInfo + ResolveAnnotSquareMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveAnnotSquareMethod "getDate" o = Poppler.AnnotMarkup.AnnotMarkupGetDateMethodInfo + ResolveAnnotSquareMethod "getExternalData" o = Poppler.AnnotMarkup.AnnotMarkupGetExternalDataMethodInfo + ResolveAnnotSquareMethod "getFlags" o = Poppler.Annot.AnnotGetFlagsMethodInfo + ResolveAnnotSquareMethod "getInteriorColor" o = AnnotSquareGetInteriorColorMethodInfo + ResolveAnnotSquareMethod "getLabel" o = Poppler.AnnotMarkup.AnnotMarkupGetLabelMethodInfo + ResolveAnnotSquareMethod "getModified" o = Poppler.Annot.AnnotGetModifiedMethodInfo + ResolveAnnotSquareMethod "getName" o = Poppler.Annot.AnnotGetNameMethodInfo + ResolveAnnotSquareMethod "getOpacity" o = Poppler.AnnotMarkup.AnnotMarkupGetOpacityMethodInfo + ResolveAnnotSquareMethod "getPageIndex" o = Poppler.Annot.AnnotGetPageIndexMethodInfo + ResolveAnnotSquareMethod "getPopupIsOpen" o = Poppler.AnnotMarkup.AnnotMarkupGetPopupIsOpenMethodInfo + ResolveAnnotSquareMethod "getPopupRectangle" o = Poppler.AnnotMarkup.AnnotMarkupGetPopupRectangleMethodInfo + ResolveAnnotSquareMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveAnnotSquareMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveAnnotSquareMethod "getRectangle" o = Poppler.Annot.AnnotGetRectangleMethodInfo + ResolveAnnotSquareMethod "getReplyTo" o = Poppler.AnnotMarkup.AnnotMarkupGetReplyToMethodInfo + ResolveAnnotSquareMethod "getSubject" o = Poppler.AnnotMarkup.AnnotMarkupGetSubjectMethodInfo + ResolveAnnotSquareMethod "setColor" o = Poppler.Annot.AnnotSetColorMethodInfo + ResolveAnnotSquareMethod "setContents" o = Poppler.Annot.AnnotSetContentsMethodInfo + ResolveAnnotSquareMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveAnnotSquareMethod "setFlags" o = Poppler.Annot.AnnotSetFlagsMethodInfo + ResolveAnnotSquareMethod "setInteriorColor" o = AnnotSquareSetInteriorColorMethodInfo + ResolveAnnotSquareMethod "setLabel" o = Poppler.AnnotMarkup.AnnotMarkupSetLabelMethodInfo + ResolveAnnotSquareMethod "setOpacity" o = Poppler.AnnotMarkup.AnnotMarkupSetOpacityMethodInfo + ResolveAnnotSquareMethod "setPopup" o = Poppler.AnnotMarkup.AnnotMarkupSetPopupMethodInfo + ResolveAnnotSquareMethod "setPopupIsOpen" o = Poppler.AnnotMarkup.AnnotMarkupSetPopupIsOpenMethodInfo + ResolveAnnotSquareMethod "setPopupRectangle" o = Poppler.AnnotMarkup.AnnotMarkupSetPopupRectangleMethodInfo + ResolveAnnotSquareMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveAnnotSquareMethod "setRectangle" o = Poppler.Annot.AnnotSetRectangleMethodInfo + ResolveAnnotSquareMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveAnnotSquareMethod t AnnotSquare, O.MethodInfo info AnnotSquare p) => OL.IsLabel t (AnnotSquare -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList AnnotSquare +type instance O.AttributeList AnnotSquare = AnnotSquareAttributeList +type AnnotSquareAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList AnnotSquare = AnnotSquareSignalList +type AnnotSquareSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method AnnotSquare::new +-- method type : Constructor +-- Args : [Arg {argCName = "doc", argType = TInterface (Name {namespace = "Poppler", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rect", argType = TInterface (Name {namespace = "Poppler", name = "Rectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerRectangle", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "AnnotSquare"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_annot_square_new" poppler_annot_square_new :: + Ptr Poppler.Document.Document -> -- doc : TInterface (Name {namespace = "Poppler", name = "Document"}) + Ptr Poppler.Rectangle.Rectangle -> -- rect : TInterface (Name {namespace = "Poppler", name = "Rectangle"}) + IO (Ptr AnnotSquare) + +{- | +Creates a new Square annotation that will be +located on /@rect@/ when added to a page. See +'GI.Poppler.Objects.Page.pageAddAnnot' + +/Since: 0.26/ +-} +annotSquareNew :: + (B.CallStack.HasCallStack, MonadIO m, Poppler.Document.IsDocument a) => + a + {- ^ /@doc@/: a 'GI.Poppler.Objects.Document.Document' -} + -> Poppler.Rectangle.Rectangle + {- ^ /@rect@/: a 'GI.Poppler.Structs.Rectangle.Rectangle' -} + -> m AnnotSquare + {- ^ __Returns:__ a newly created 'GI.Poppler.Objects.AnnotSquare.AnnotSquare' annotation -} +annotSquareNew doc rect = liftIO $ do + doc' <- unsafeManagedPtrCastPtr doc + rect' <- unsafeManagedPtrGetPtr rect + result <- poppler_annot_square_new doc' rect' + checkUnexpectedReturnNULL "annotSquareNew" result + result' <- (wrapObject AnnotSquare) result + touchManagedPtr doc + touchManagedPtr rect + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method AnnotSquare::get_interior_color +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_annot", argType = TInterface (Name {namespace = "Poppler", name = "AnnotSquare"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerAnnotSquare", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "Color"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_annot_square_get_interior_color" poppler_annot_square_get_interior_color :: + Ptr AnnotSquare -> -- poppler_annot : TInterface (Name {namespace = "Poppler", name = "AnnotSquare"}) + IO (Ptr Poppler.Color.Color) + +{- | +Retrieves the interior color of /@popplerAnnot@/. + +/Since: 0.26/ +-} +annotSquareGetInteriorColor :: + (B.CallStack.HasCallStack, MonadIO m, IsAnnotSquare a) => + a + {- ^ /@popplerAnnot@/: a 'GI.Poppler.Objects.AnnotSquare.AnnotSquare' -} + -> m Poppler.Color.Color + {- ^ __Returns:__ a new allocated 'GI.Poppler.Structs.Color.Color' with the color values of + /@popplerAnnot@/, or 'Nothing'. It must be freed with 'GI.GLib.Functions.free' when done. -} +annotSquareGetInteriorColor popplerAnnot = liftIO $ do + popplerAnnot' <- unsafeManagedPtrCastPtr popplerAnnot + result <- poppler_annot_square_get_interior_color popplerAnnot' + checkUnexpectedReturnNULL "annotSquareGetInteriorColor" result + result' <- (wrapBoxed Poppler.Color.Color) result + touchManagedPtr popplerAnnot + return result' + +#if ENABLE_OVERLOADING +data AnnotSquareGetInteriorColorMethodInfo +instance (signature ~ (m Poppler.Color.Color), MonadIO m, IsAnnotSquare a) => O.MethodInfo AnnotSquareGetInteriorColorMethodInfo a signature where + overloadedMethod _ = annotSquareGetInteriorColor + +#endif + +-- method AnnotSquare::set_interior_color +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_annot", argType = TInterface (Name {namespace = "Poppler", name = "AnnotSquare"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerAnnotSquare", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "poppler_color", argType = TInterface (Name {namespace = "Poppler", name = "Color"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #PopplerColor, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_annot_square_set_interior_color" poppler_annot_square_set_interior_color :: + Ptr AnnotSquare -> -- poppler_annot : TInterface (Name {namespace = "Poppler", name = "AnnotSquare"}) + Ptr Poppler.Color.Color -> -- poppler_color : TInterface (Name {namespace = "Poppler", name = "Color"}) + IO () + +{- | +Sets the interior color of /@popplerAnnot@/. + +/Since: 0.26/ +-} +annotSquareSetInteriorColor :: + (B.CallStack.HasCallStack, MonadIO m, IsAnnotSquare a) => + a + {- ^ /@popplerAnnot@/: a 'GI.Poppler.Objects.AnnotSquare.AnnotSquare' -} + -> Maybe (Poppler.Color.Color) + {- ^ /@popplerColor@/: a 'GI.Poppler.Structs.Color.Color', or 'Nothing' -} + -> m () +annotSquareSetInteriorColor popplerAnnot popplerColor = liftIO $ do + popplerAnnot' <- unsafeManagedPtrCastPtr popplerAnnot + maybePopplerColor <- case popplerColor of + Nothing -> return nullPtr + Just jPopplerColor -> do + jPopplerColor' <- unsafeManagedPtrGetPtr jPopplerColor + return jPopplerColor' + poppler_annot_square_set_interior_color popplerAnnot' maybePopplerColor + touchManagedPtr popplerAnnot + whenJust popplerColor touchManagedPtr + return () + +#if ENABLE_OVERLOADING +data AnnotSquareSetInteriorColorMethodInfo +instance (signature ~ (Maybe (Poppler.Color.Color) -> m ()), MonadIO m, IsAnnotSquare a) => O.MethodInfo AnnotSquareSetInteriorColorMethodInfo a signature where + overloadedMethod _ = annotSquareSetInteriorColor + +#endif + + 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,35 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Poppler.Objects.AnnotSquare where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype AnnotSquare = AnnotSquare (ManagedPtr AnnotSquare) +instance GObject AnnotSquare where +class (GObject o, O.IsDescendantOf AnnotSquare o) => IsAnnotSquare o +instance (GObject o, O.IsDescendantOf AnnotSquare o) => IsAnnotSquare o +instance O.HasParentTypes AnnotSquare +#if ENABLE_OVERLOADING +data AnnotSquareGetInteriorColorMethodInfo +#endif +#if ENABLE_OVERLOADING +data AnnotSquareSetInteriorColorMethodInfo +#endif 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,463 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Poppler.Objects.AnnotText + ( + +-- * Exported types + AnnotText(..) , + IsAnnotText , + toAnnotText , + noAnnotText , + + + -- * Methods +-- ** getIcon #method:getIcon# + +#if ENABLE_OVERLOADING + AnnotTextGetIconMethodInfo , +#endif + annotTextGetIcon , + + +-- ** getIsOpen #method:getIsOpen# + +#if ENABLE_OVERLOADING + AnnotTextGetIsOpenMethodInfo , +#endif + annotTextGetIsOpen , + + +-- ** getState #method:getState# + +#if ENABLE_OVERLOADING + AnnotTextGetStateMethodInfo , +#endif + annotTextGetState , + + +-- ** new #method:new# + + annotTextNew , + + +-- ** setIcon #method:setIcon# + +#if ENABLE_OVERLOADING + AnnotTextSetIconMethodInfo , +#endif + annotTextSetIcon , + + +-- ** setIsOpen #method:setIsOpen# + +#if ENABLE_OVERLOADING + AnnotTextSetIsOpenMethodInfo , +#endif + annotTextSetIsOpen , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import qualified GI.GObject.Objects.Object as GObject.Object +import {-# SOURCE #-} qualified GI.Poppler.Enums as Poppler.Enums +import {-# SOURCE #-} qualified GI.Poppler.Objects.Annot as Poppler.Annot +import {-# SOURCE #-} qualified GI.Poppler.Objects.AnnotMarkup as Poppler.AnnotMarkup +import {-# SOURCE #-} qualified GI.Poppler.Objects.Document as Poppler.Document +import {-# SOURCE #-} qualified GI.Poppler.Structs.Rectangle as Poppler.Rectangle + +-- | Memory-managed wrapper type. +newtype AnnotText = AnnotText (ManagedPtr AnnotText) +foreign import ccall "poppler_annot_text_get_type" + c_poppler_annot_text_get_type :: IO GType + +instance GObject AnnotText where + gobjectType = c_poppler_annot_text_get_type + + +-- | Type class for types which can be safely cast to `AnnotText`, for instance with `toAnnotText`. +class (GObject o, O.IsDescendantOf AnnotText o) => IsAnnotText o +instance (GObject o, O.IsDescendantOf AnnotText o) => IsAnnotText o + +instance O.HasParentTypes AnnotText +type instance O.ParentTypes AnnotText = '[Poppler.AnnotMarkup.AnnotMarkup, Poppler.Annot.Annot, GObject.Object.Object] + +-- | Cast to `AnnotText`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toAnnotText :: (MonadIO m, IsAnnotText o) => o -> m AnnotText +toAnnotText = liftIO . unsafeCastTo AnnotText + +-- | A convenience alias for `Nothing` :: `Maybe` `AnnotText`. +noAnnotText :: Maybe AnnotText +noAnnotText = Nothing + +#if ENABLE_OVERLOADING +type family ResolveAnnotTextMethod (t :: Symbol) (o :: *) :: * where + ResolveAnnotTextMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveAnnotTextMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveAnnotTextMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveAnnotTextMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveAnnotTextMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveAnnotTextMethod "hasPopup" o = Poppler.AnnotMarkup.AnnotMarkupHasPopupMethodInfo + ResolveAnnotTextMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveAnnotTextMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveAnnotTextMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveAnnotTextMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveAnnotTextMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveAnnotTextMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveAnnotTextMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveAnnotTextMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveAnnotTextMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveAnnotTextMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveAnnotTextMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveAnnotTextMethod "getAnnotType" o = Poppler.Annot.AnnotGetAnnotTypeMethodInfo + ResolveAnnotTextMethod "getColor" o = Poppler.Annot.AnnotGetColorMethodInfo + ResolveAnnotTextMethod "getContents" o = Poppler.Annot.AnnotGetContentsMethodInfo + ResolveAnnotTextMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveAnnotTextMethod "getDate" o = Poppler.AnnotMarkup.AnnotMarkupGetDateMethodInfo + ResolveAnnotTextMethod "getExternalData" o = Poppler.AnnotMarkup.AnnotMarkupGetExternalDataMethodInfo + ResolveAnnotTextMethod "getFlags" o = Poppler.Annot.AnnotGetFlagsMethodInfo + ResolveAnnotTextMethod "getIcon" o = AnnotTextGetIconMethodInfo + ResolveAnnotTextMethod "getIsOpen" o = AnnotTextGetIsOpenMethodInfo + ResolveAnnotTextMethod "getLabel" o = Poppler.AnnotMarkup.AnnotMarkupGetLabelMethodInfo + ResolveAnnotTextMethod "getModified" o = Poppler.Annot.AnnotGetModifiedMethodInfo + ResolveAnnotTextMethod "getName" o = Poppler.Annot.AnnotGetNameMethodInfo + ResolveAnnotTextMethod "getOpacity" o = Poppler.AnnotMarkup.AnnotMarkupGetOpacityMethodInfo + ResolveAnnotTextMethod "getPageIndex" o = Poppler.Annot.AnnotGetPageIndexMethodInfo + ResolveAnnotTextMethod "getPopupIsOpen" o = Poppler.AnnotMarkup.AnnotMarkupGetPopupIsOpenMethodInfo + ResolveAnnotTextMethod "getPopupRectangle" o = Poppler.AnnotMarkup.AnnotMarkupGetPopupRectangleMethodInfo + ResolveAnnotTextMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveAnnotTextMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveAnnotTextMethod "getRectangle" o = Poppler.Annot.AnnotGetRectangleMethodInfo + ResolveAnnotTextMethod "getReplyTo" o = Poppler.AnnotMarkup.AnnotMarkupGetReplyToMethodInfo + ResolveAnnotTextMethod "getState" o = AnnotTextGetStateMethodInfo + ResolveAnnotTextMethod "getSubject" o = Poppler.AnnotMarkup.AnnotMarkupGetSubjectMethodInfo + ResolveAnnotTextMethod "setColor" o = Poppler.Annot.AnnotSetColorMethodInfo + ResolveAnnotTextMethod "setContents" o = Poppler.Annot.AnnotSetContentsMethodInfo + ResolveAnnotTextMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveAnnotTextMethod "setFlags" o = Poppler.Annot.AnnotSetFlagsMethodInfo + ResolveAnnotTextMethod "setIcon" o = AnnotTextSetIconMethodInfo + ResolveAnnotTextMethod "setIsOpen" o = AnnotTextSetIsOpenMethodInfo + ResolveAnnotTextMethod "setLabel" o = Poppler.AnnotMarkup.AnnotMarkupSetLabelMethodInfo + ResolveAnnotTextMethod "setOpacity" o = Poppler.AnnotMarkup.AnnotMarkupSetOpacityMethodInfo + ResolveAnnotTextMethod "setPopup" o = Poppler.AnnotMarkup.AnnotMarkupSetPopupMethodInfo + ResolveAnnotTextMethod "setPopupIsOpen" o = Poppler.AnnotMarkup.AnnotMarkupSetPopupIsOpenMethodInfo + ResolveAnnotTextMethod "setPopupRectangle" o = Poppler.AnnotMarkup.AnnotMarkupSetPopupRectangleMethodInfo + ResolveAnnotTextMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveAnnotTextMethod "setRectangle" o = Poppler.Annot.AnnotSetRectangleMethodInfo + ResolveAnnotTextMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveAnnotTextMethod t AnnotText, O.MethodInfo info AnnotText p) => OL.IsLabel t (AnnotText -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList AnnotText +type instance O.AttributeList AnnotText = AnnotTextAttributeList +type AnnotTextAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList AnnotText = AnnotTextSignalList +type AnnotTextSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method AnnotText::new +-- method type : Constructor +-- Args : [Arg {argCName = "doc", argType = TInterface (Name {namespace = "Poppler", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rect", argType = TInterface (Name {namespace = "Poppler", name = "Rectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerRectangle", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "AnnotText"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_annot_text_new" poppler_annot_text_new :: + Ptr Poppler.Document.Document -> -- doc : TInterface (Name {namespace = "Poppler", name = "Document"}) + Ptr Poppler.Rectangle.Rectangle -> -- rect : TInterface (Name {namespace = "Poppler", name = "Rectangle"}) + IO (Ptr AnnotText) + +{- | +Creates a new Text annotation that will be +located on /@rect@/ when added to a page. See +'GI.Poppler.Objects.Page.pageAddAnnot' + +/Since: 0.16/ +-} +annotTextNew :: + (B.CallStack.HasCallStack, MonadIO m, Poppler.Document.IsDocument a) => + a + {- ^ /@doc@/: a 'GI.Poppler.Objects.Document.Document' -} + -> Poppler.Rectangle.Rectangle + {- ^ /@rect@/: a 'GI.Poppler.Structs.Rectangle.Rectangle' -} + -> m AnnotText + {- ^ __Returns:__ A newly created 'GI.Poppler.Objects.AnnotText.AnnotText' annotation -} +annotTextNew doc rect = liftIO $ do + doc' <- unsafeManagedPtrCastPtr doc + rect' <- unsafeManagedPtrGetPtr rect + result <- poppler_annot_text_new doc' rect' + checkUnexpectedReturnNULL "annotTextNew" result + result' <- (wrapObject AnnotText) result + touchManagedPtr doc + touchManagedPtr rect + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method AnnotText::get_icon +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_annot", argType = TInterface (Name {namespace = "Poppler", name = "AnnotText"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerAnnotText", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_annot_text_get_icon" poppler_annot_text_get_icon :: + Ptr AnnotText -> -- poppler_annot : TInterface (Name {namespace = "Poppler", name = "AnnotText"}) + IO CString + +{- | +Gets name of the icon of /@popplerAnnot@/. +-} +annotTextGetIcon :: + (B.CallStack.HasCallStack, MonadIO m, IsAnnotText a) => + a + {- ^ /@popplerAnnot@/: a 'GI.Poppler.Objects.AnnotText.AnnotText' -} + -> m T.Text + {- ^ __Returns:__ a new allocated string containing the icon name -} +annotTextGetIcon popplerAnnot = liftIO $ do + popplerAnnot' <- unsafeManagedPtrCastPtr popplerAnnot + result <- poppler_annot_text_get_icon popplerAnnot' + checkUnexpectedReturnNULL "annotTextGetIcon" result + result' <- cstringToText result + freeMem result + touchManagedPtr popplerAnnot + return result' + +#if ENABLE_OVERLOADING +data AnnotTextGetIconMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsAnnotText a) => O.MethodInfo AnnotTextGetIconMethodInfo a signature where + overloadedMethod _ = annotTextGetIcon + +#endif + +-- method AnnotText::get_is_open +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_annot", argType = TInterface (Name {namespace = "Poppler", name = "AnnotText"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerAnnotText", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_annot_text_get_is_open" poppler_annot_text_get_is_open :: + Ptr AnnotText -> -- poppler_annot : TInterface (Name {namespace = "Poppler", name = "AnnotText"}) + IO CInt + +{- | +Retrieves the state of /@popplerAnnot@/. +-} +annotTextGetIsOpen :: + (B.CallStack.HasCallStack, MonadIO m, IsAnnotText a) => + a + {- ^ /@popplerAnnot@/: a 'GI.Poppler.Objects.AnnotText.AnnotText' -} + -> m Bool + {- ^ __Returns:__ the state of /@popplerAnnot@/. 'True' if it\'s open, 'False' in + other case. -} +annotTextGetIsOpen popplerAnnot = liftIO $ do + popplerAnnot' <- unsafeManagedPtrCastPtr popplerAnnot + result <- poppler_annot_text_get_is_open popplerAnnot' + let result' = (/= 0) result + touchManagedPtr popplerAnnot + return result' + +#if ENABLE_OVERLOADING +data AnnotTextGetIsOpenMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsAnnotText a) => O.MethodInfo AnnotTextGetIsOpenMethodInfo a signature where + overloadedMethod _ = annotTextGetIsOpen + +#endif + +-- method AnnotText::get_state +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_annot", argType = TInterface (Name {namespace = "Poppler", name = "AnnotText"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerAnnotText", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "AnnotTextState"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_annot_text_get_state" poppler_annot_text_get_state :: + Ptr AnnotText -> -- poppler_annot : TInterface (Name {namespace = "Poppler", name = "AnnotText"}) + IO CUInt + +{- | +Retrieves the state of /@popplerAnnot@/. +-} +annotTextGetState :: + (B.CallStack.HasCallStack, MonadIO m, IsAnnotText a) => + a + {- ^ /@popplerAnnot@/: a 'GI.Poppler.Objects.AnnotText.AnnotText' -} + -> m Poppler.Enums.AnnotTextState + {- ^ __Returns:__ 'GI.Poppler.Enums.AnnotTextState' of /@popplerAnnot@/. -} +annotTextGetState popplerAnnot = liftIO $ do + popplerAnnot' <- unsafeManagedPtrCastPtr popplerAnnot + result <- poppler_annot_text_get_state popplerAnnot' + let result' = (toEnum . fromIntegral) result + touchManagedPtr popplerAnnot + return result' + +#if ENABLE_OVERLOADING +data AnnotTextGetStateMethodInfo +instance (signature ~ (m Poppler.Enums.AnnotTextState), MonadIO m, IsAnnotText a) => O.MethodInfo AnnotTextGetStateMethodInfo a signature where + overloadedMethod _ = annotTextGetState + +#endif + +-- method AnnotText::set_icon +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_annot", argType = TInterface (Name {namespace = "Poppler", name = "AnnotText"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerAnnotText", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "icon", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of an icon", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_annot_text_set_icon" poppler_annot_text_set_icon :: + Ptr AnnotText -> -- poppler_annot : TInterface (Name {namespace = "Poppler", name = "AnnotText"}) + CString -> -- icon : TBasicType TUTF8 + IO () + +{- | +Sets the icon of /@popplerAnnot@/. The following predefined +icons are currently supported: +\ + \ + \'GI.Poppler.Constants.ANNOT_TEXT_ICON_NOTE'\<\/term> + \<\/varlistentry> + \ + \'GI.Poppler.Constants.ANNOT_TEXT_ICON_COMMENT'\<\/term> + \<\/varlistentry> + \ + \'GI.Poppler.Constants.ANNOT_TEXT_ICON_KEY'\<\/term> + \<\/varlistentry> + \ + \'GI.Poppler.Constants.ANNOT_TEXT_ICON_HELP'\<\/term> + \<\/varlistentry> + \ + \'GI.Poppler.Constants.ANNOT_TEXT_ICON_NEW_PARAGRAPH'\<\/term> + \<\/varlistentry> + \ + \'GI.Poppler.Constants.ANNOT_TEXT_ICON_PARAGRAPH'\<\/term> + \<\/varlistentry> + \ + \'GI.Poppler.Constants.ANNOT_TEXT_ICON_INSERT'\<\/term> + \<\/varlistentry> + \ + \'GI.Poppler.Constants.ANNOT_TEXT_ICON_CROSS'\<\/term> + \<\/varlistentry> + \ + \'GI.Poppler.Constants.ANNOT_TEXT_ICON_CIRCLE'\<\/term> + \<\/varlistentry> +\<\/variablelist> + +/Since: 0.16/ +-} +annotTextSetIcon :: + (B.CallStack.HasCallStack, MonadIO m, IsAnnotText a) => + a + {- ^ /@popplerAnnot@/: a 'GI.Poppler.Objects.AnnotText.AnnotText' -} + -> T.Text + {- ^ /@icon@/: the name of an icon -} + -> m () +annotTextSetIcon popplerAnnot icon = liftIO $ do + popplerAnnot' <- unsafeManagedPtrCastPtr popplerAnnot + icon' <- textToCString icon + poppler_annot_text_set_icon popplerAnnot' icon' + touchManagedPtr popplerAnnot + freeMem icon' + return () + +#if ENABLE_OVERLOADING +data AnnotTextSetIconMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsAnnotText a) => O.MethodInfo AnnotTextSetIconMethodInfo a signature where + overloadedMethod _ = annotTextSetIcon + +#endif + +-- method AnnotText::set_is_open +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_annot", argType = TInterface (Name {namespace = "Poppler", name = "AnnotText"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerAnnotText", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "is_open", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether annotation should initially be displayed open", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_annot_text_set_is_open" poppler_annot_text_set_is_open :: + Ptr AnnotText -> -- poppler_annot : TInterface (Name {namespace = "Poppler", name = "AnnotText"}) + CInt -> -- is_open : TBasicType TBoolean + IO () + +{- | +Sets whether /@popplerAnnot@/ should initially be displayed open + +/Since: 0.16/ +-} +annotTextSetIsOpen :: + (B.CallStack.HasCallStack, MonadIO m, IsAnnotText a) => + a + {- ^ /@popplerAnnot@/: a 'GI.Poppler.Objects.AnnotText.AnnotText' -} + -> Bool + {- ^ /@isOpen@/: whether annotation should initially be displayed open -} + -> m () +annotTextSetIsOpen popplerAnnot isOpen = liftIO $ do + popplerAnnot' <- unsafeManagedPtrCastPtr popplerAnnot + let isOpen' = (fromIntegral . fromEnum) isOpen + poppler_annot_text_set_is_open popplerAnnot' isOpen' + touchManagedPtr popplerAnnot + return () + +#if ENABLE_OVERLOADING +data AnnotTextSetIsOpenMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsAnnotText a) => O.MethodInfo AnnotTextSetIsOpenMethodInfo a signature where + overloadedMethod _ = annotTextSetIsOpen + +#endif + + 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,44 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Poppler.Objects.AnnotText where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype AnnotText = AnnotText (ManagedPtr AnnotText) +instance GObject AnnotText where +class (GObject o, O.IsDescendantOf AnnotText o) => IsAnnotText o +instance (GObject o, O.IsDescendantOf AnnotText o) => IsAnnotText o +instance O.HasParentTypes AnnotText +#if ENABLE_OVERLOADING +data AnnotTextGetIconMethodInfo +#endif +#if ENABLE_OVERLOADING +data AnnotTextGetIsOpenMethodInfo +#endif +#if ENABLE_OVERLOADING +data AnnotTextGetStateMethodInfo +#endif +#if ENABLE_OVERLOADING +data AnnotTextSetIconMethodInfo +#endif +#if ENABLE_OVERLOADING +data AnnotTextSetIsOpenMethodInfo +#endif 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,470 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Poppler.Objects.AnnotTextMarkup + ( + +-- * Exported types + AnnotTextMarkup(..) , + IsAnnotTextMarkup , + toAnnotTextMarkup , + noAnnotTextMarkup , + + + -- * Methods +-- ** getQuadrilaterals #method:getQuadrilaterals# + +#if ENABLE_OVERLOADING + AnnotTextMarkupGetQuadrilateralsMethodInfo, +#endif + annotTextMarkupGetQuadrilaterals , + + +-- ** newHighlight #method:newHighlight# + + annotTextMarkupNewHighlight , + + +-- ** newSquiggly #method:newSquiggly# + + annotTextMarkupNewSquiggly , + + +-- ** newStrikeout #method:newStrikeout# + + annotTextMarkupNewStrikeout , + + +-- ** newUnderline #method:newUnderline# + + annotTextMarkupNewUnderline , + + +-- ** setQuadrilaterals #method:setQuadrilaterals# + +#if ENABLE_OVERLOADING + AnnotTextMarkupSetQuadrilateralsMethodInfo, +#endif + annotTextMarkupSetQuadrilaterals , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import qualified GI.GObject.Objects.Object as GObject.Object +import {-# SOURCE #-} qualified GI.Poppler.Objects.Annot as Poppler.Annot +import {-# SOURCE #-} qualified GI.Poppler.Objects.AnnotMarkup as Poppler.AnnotMarkup +import {-# SOURCE #-} qualified GI.Poppler.Objects.Document as Poppler.Document +import {-# SOURCE #-} qualified GI.Poppler.Structs.Quadrilateral as Poppler.Quadrilateral +import {-# SOURCE #-} qualified GI.Poppler.Structs.Rectangle as Poppler.Rectangle + +-- | Memory-managed wrapper type. +newtype AnnotTextMarkup = AnnotTextMarkup (ManagedPtr AnnotTextMarkup) +foreign import ccall "poppler_annot_text_markup_get_type" + c_poppler_annot_text_markup_get_type :: IO GType + +instance GObject AnnotTextMarkup where + gobjectType = c_poppler_annot_text_markup_get_type + + +-- | Type class for types which can be safely cast to `AnnotTextMarkup`, for instance with `toAnnotTextMarkup`. +class (GObject o, O.IsDescendantOf AnnotTextMarkup o) => IsAnnotTextMarkup o +instance (GObject o, O.IsDescendantOf AnnotTextMarkup o) => IsAnnotTextMarkup o + +instance O.HasParentTypes AnnotTextMarkup +type instance O.ParentTypes AnnotTextMarkup = '[Poppler.AnnotMarkup.AnnotMarkup, Poppler.Annot.Annot, GObject.Object.Object] + +-- | Cast to `AnnotTextMarkup`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toAnnotTextMarkup :: (MonadIO m, IsAnnotTextMarkup o) => o -> m AnnotTextMarkup +toAnnotTextMarkup = liftIO . unsafeCastTo AnnotTextMarkup + +-- | A convenience alias for `Nothing` :: `Maybe` `AnnotTextMarkup`. +noAnnotTextMarkup :: Maybe AnnotTextMarkup +noAnnotTextMarkup = Nothing + +#if ENABLE_OVERLOADING +type family ResolveAnnotTextMarkupMethod (t :: Symbol) (o :: *) :: * where + ResolveAnnotTextMarkupMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveAnnotTextMarkupMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveAnnotTextMarkupMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveAnnotTextMarkupMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveAnnotTextMarkupMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveAnnotTextMarkupMethod "hasPopup" o = Poppler.AnnotMarkup.AnnotMarkupHasPopupMethodInfo + ResolveAnnotTextMarkupMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveAnnotTextMarkupMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveAnnotTextMarkupMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveAnnotTextMarkupMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveAnnotTextMarkupMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveAnnotTextMarkupMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveAnnotTextMarkupMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveAnnotTextMarkupMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveAnnotTextMarkupMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveAnnotTextMarkupMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveAnnotTextMarkupMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveAnnotTextMarkupMethod "getAnnotType" o = Poppler.Annot.AnnotGetAnnotTypeMethodInfo + ResolveAnnotTextMarkupMethod "getColor" o = Poppler.Annot.AnnotGetColorMethodInfo + ResolveAnnotTextMarkupMethod "getContents" o = Poppler.Annot.AnnotGetContentsMethodInfo + ResolveAnnotTextMarkupMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveAnnotTextMarkupMethod "getDate" o = Poppler.AnnotMarkup.AnnotMarkupGetDateMethodInfo + ResolveAnnotTextMarkupMethod "getExternalData" o = Poppler.AnnotMarkup.AnnotMarkupGetExternalDataMethodInfo + ResolveAnnotTextMarkupMethod "getFlags" o = Poppler.Annot.AnnotGetFlagsMethodInfo + ResolveAnnotTextMarkupMethod "getLabel" o = Poppler.AnnotMarkup.AnnotMarkupGetLabelMethodInfo + ResolveAnnotTextMarkupMethod "getModified" o = Poppler.Annot.AnnotGetModifiedMethodInfo + ResolveAnnotTextMarkupMethod "getName" o = Poppler.Annot.AnnotGetNameMethodInfo + ResolveAnnotTextMarkupMethod "getOpacity" o = Poppler.AnnotMarkup.AnnotMarkupGetOpacityMethodInfo + ResolveAnnotTextMarkupMethod "getPageIndex" o = Poppler.Annot.AnnotGetPageIndexMethodInfo + ResolveAnnotTextMarkupMethod "getPopupIsOpen" o = Poppler.AnnotMarkup.AnnotMarkupGetPopupIsOpenMethodInfo + ResolveAnnotTextMarkupMethod "getPopupRectangle" o = Poppler.AnnotMarkup.AnnotMarkupGetPopupRectangleMethodInfo + ResolveAnnotTextMarkupMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveAnnotTextMarkupMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveAnnotTextMarkupMethod "getQuadrilaterals" o = AnnotTextMarkupGetQuadrilateralsMethodInfo + ResolveAnnotTextMarkupMethod "getRectangle" o = Poppler.Annot.AnnotGetRectangleMethodInfo + ResolveAnnotTextMarkupMethod "getReplyTo" o = Poppler.AnnotMarkup.AnnotMarkupGetReplyToMethodInfo + ResolveAnnotTextMarkupMethod "getSubject" o = Poppler.AnnotMarkup.AnnotMarkupGetSubjectMethodInfo + ResolveAnnotTextMarkupMethod "setColor" o = Poppler.Annot.AnnotSetColorMethodInfo + ResolveAnnotTextMarkupMethod "setContents" o = Poppler.Annot.AnnotSetContentsMethodInfo + ResolveAnnotTextMarkupMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveAnnotTextMarkupMethod "setFlags" o = Poppler.Annot.AnnotSetFlagsMethodInfo + ResolveAnnotTextMarkupMethod "setLabel" o = Poppler.AnnotMarkup.AnnotMarkupSetLabelMethodInfo + ResolveAnnotTextMarkupMethod "setOpacity" o = Poppler.AnnotMarkup.AnnotMarkupSetOpacityMethodInfo + ResolveAnnotTextMarkupMethod "setPopup" o = Poppler.AnnotMarkup.AnnotMarkupSetPopupMethodInfo + ResolveAnnotTextMarkupMethod "setPopupIsOpen" o = Poppler.AnnotMarkup.AnnotMarkupSetPopupIsOpenMethodInfo + ResolveAnnotTextMarkupMethod "setPopupRectangle" o = Poppler.AnnotMarkup.AnnotMarkupSetPopupRectangleMethodInfo + ResolveAnnotTextMarkupMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveAnnotTextMarkupMethod "setQuadrilaterals" o = AnnotTextMarkupSetQuadrilateralsMethodInfo + ResolveAnnotTextMarkupMethod "setRectangle" o = Poppler.Annot.AnnotSetRectangleMethodInfo + ResolveAnnotTextMarkupMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveAnnotTextMarkupMethod t AnnotTextMarkup, O.MethodInfo info AnnotTextMarkup p) => OL.IsLabel t (AnnotTextMarkup -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList AnnotTextMarkup +type instance O.AttributeList AnnotTextMarkup = AnnotTextMarkupAttributeList +type AnnotTextMarkupAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList AnnotTextMarkup = AnnotTextMarkupSignalList +type AnnotTextMarkupSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method AnnotTextMarkup::new_highlight +-- method type : Constructor +-- Args : [Arg {argCName = "doc", argType = TInterface (Name {namespace = "Poppler", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rect", argType = TInterface (Name {namespace = "Poppler", name = "Rectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerRectangle", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "quadrilaterals", argType = TGArray (TInterface (Name {namespace = "Poppler", name = "Quadrilateral"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GArray of\n #PopplerQuadrilaterals", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "AnnotTextMarkup"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_annot_text_markup_new_highlight" poppler_annot_text_markup_new_highlight :: + Ptr Poppler.Document.Document -> -- doc : TInterface (Name {namespace = "Poppler", name = "Document"}) + Ptr Poppler.Rectangle.Rectangle -> -- rect : TInterface (Name {namespace = "Poppler", name = "Rectangle"}) + Ptr (GArray (Ptr Poppler.Quadrilateral.Quadrilateral)) -> -- quadrilaterals : TGArray (TInterface (Name {namespace = "Poppler", name = "Quadrilateral"})) + IO (Ptr AnnotTextMarkup) + +{- | +Creates a new Highlight Text annotation that will be +located on /@rect@/ when added to a page. See 'GI.Poppler.Objects.Page.pageAddAnnot' + +/Since: 0.26/ +-} +annotTextMarkupNewHighlight :: + (B.CallStack.HasCallStack, MonadIO m, Poppler.Document.IsDocument a) => + a + {- ^ /@doc@/: a 'GI.Poppler.Objects.Document.Document' -} + -> Poppler.Rectangle.Rectangle + {- ^ /@rect@/: a 'GI.Poppler.Structs.Rectangle.Rectangle' -} + -> [Poppler.Quadrilateral.Quadrilateral] + {- ^ /@quadrilaterals@/: A 'GI.GLib.Structs.Array.Array' of + 'GI.Poppler.Structs.Quadrilateral.Quadrilateral'\s -} + -> m AnnotTextMarkup + {- ^ __Returns:__ A newly created 'GI.Poppler.Objects.AnnotTextMarkup.AnnotTextMarkup' annotation -} +annotTextMarkupNewHighlight doc rect quadrilaterals = liftIO $ do + doc' <- unsafeManagedPtrCastPtr doc + rect' <- unsafeManagedPtrGetPtr rect + quadrilaterals' <- mapM unsafeManagedPtrGetPtr quadrilaterals + quadrilaterals'' <- packGArray quadrilaterals' + result <- poppler_annot_text_markup_new_highlight doc' rect' quadrilaterals'' + checkUnexpectedReturnNULL "annotTextMarkupNewHighlight" result + result' <- (wrapObject AnnotTextMarkup) result + touchManagedPtr doc + touchManagedPtr rect + mapM_ touchManagedPtr quadrilaterals + unrefGArray quadrilaterals'' + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method AnnotTextMarkup::new_squiggly +-- method type : Constructor +-- Args : [Arg {argCName = "doc", argType = TInterface (Name {namespace = "Poppler", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rect", argType = TInterface (Name {namespace = "Poppler", name = "Rectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerRectangle", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "quadrilaterals", argType = TGArray (TInterface (Name {namespace = "Poppler", name = "Quadrilateral"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GArray of\n #PopplerQuadrilaterals", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "AnnotTextMarkup"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_annot_text_markup_new_squiggly" poppler_annot_text_markup_new_squiggly :: + Ptr Poppler.Document.Document -> -- doc : TInterface (Name {namespace = "Poppler", name = "Document"}) + Ptr Poppler.Rectangle.Rectangle -> -- rect : TInterface (Name {namespace = "Poppler", name = "Rectangle"}) + Ptr (GArray (Ptr Poppler.Quadrilateral.Quadrilateral)) -> -- quadrilaterals : TGArray (TInterface (Name {namespace = "Poppler", name = "Quadrilateral"})) + IO (Ptr AnnotTextMarkup) + +{- | +Creates a new Squiggly Text annotation that will be +located on /@rect@/ when added to a page. See 'GI.Poppler.Objects.Page.pageAddAnnot' + +/Since: 0.26/ +-} +annotTextMarkupNewSquiggly :: + (B.CallStack.HasCallStack, MonadIO m, Poppler.Document.IsDocument a) => + a + {- ^ /@doc@/: a 'GI.Poppler.Objects.Document.Document' -} + -> Poppler.Rectangle.Rectangle + {- ^ /@rect@/: a 'GI.Poppler.Structs.Rectangle.Rectangle' -} + -> [Poppler.Quadrilateral.Quadrilateral] + {- ^ /@quadrilaterals@/: A 'GI.GLib.Structs.Array.Array' of + 'GI.Poppler.Structs.Quadrilateral.Quadrilateral'\s -} + -> m AnnotTextMarkup + {- ^ __Returns:__ A newly created 'GI.Poppler.Objects.AnnotTextMarkup.AnnotTextMarkup' annotation -} +annotTextMarkupNewSquiggly doc rect quadrilaterals = liftIO $ do + doc' <- unsafeManagedPtrCastPtr doc + rect' <- unsafeManagedPtrGetPtr rect + quadrilaterals' <- mapM unsafeManagedPtrGetPtr quadrilaterals + quadrilaterals'' <- packGArray quadrilaterals' + result <- poppler_annot_text_markup_new_squiggly doc' rect' quadrilaterals'' + checkUnexpectedReturnNULL "annotTextMarkupNewSquiggly" result + result' <- (wrapObject AnnotTextMarkup) result + touchManagedPtr doc + touchManagedPtr rect + mapM_ touchManagedPtr quadrilaterals + unrefGArray quadrilaterals'' + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method AnnotTextMarkup::new_strikeout +-- method type : Constructor +-- Args : [Arg {argCName = "doc", argType = TInterface (Name {namespace = "Poppler", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rect", argType = TInterface (Name {namespace = "Poppler", name = "Rectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerRectangle", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "quadrilaterals", argType = TGArray (TInterface (Name {namespace = "Poppler", name = "Quadrilateral"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GArray of\n #PopplerQuadrilaterals", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "AnnotTextMarkup"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_annot_text_markup_new_strikeout" poppler_annot_text_markup_new_strikeout :: + Ptr Poppler.Document.Document -> -- doc : TInterface (Name {namespace = "Poppler", name = "Document"}) + Ptr Poppler.Rectangle.Rectangle -> -- rect : TInterface (Name {namespace = "Poppler", name = "Rectangle"}) + Ptr (GArray (Ptr Poppler.Quadrilateral.Quadrilateral)) -> -- quadrilaterals : TGArray (TInterface (Name {namespace = "Poppler", name = "Quadrilateral"})) + IO (Ptr AnnotTextMarkup) + +{- | +Creates a new Strike Out Text annotation that will be +located on /@rect@/ when added to a page. See 'GI.Poppler.Objects.Page.pageAddAnnot' + +/Since: 0.26/ +-} +annotTextMarkupNewStrikeout :: + (B.CallStack.HasCallStack, MonadIO m, Poppler.Document.IsDocument a) => + a + {- ^ /@doc@/: a 'GI.Poppler.Objects.Document.Document' -} + -> Poppler.Rectangle.Rectangle + {- ^ /@rect@/: a 'GI.Poppler.Structs.Rectangle.Rectangle' -} + -> [Poppler.Quadrilateral.Quadrilateral] + {- ^ /@quadrilaterals@/: A 'GI.GLib.Structs.Array.Array' of + 'GI.Poppler.Structs.Quadrilateral.Quadrilateral'\s -} + -> m AnnotTextMarkup + {- ^ __Returns:__ A newly created 'GI.Poppler.Objects.AnnotTextMarkup.AnnotTextMarkup' annotation -} +annotTextMarkupNewStrikeout doc rect quadrilaterals = liftIO $ do + doc' <- unsafeManagedPtrCastPtr doc + rect' <- unsafeManagedPtrGetPtr rect + quadrilaterals' <- mapM unsafeManagedPtrGetPtr quadrilaterals + quadrilaterals'' <- packGArray quadrilaterals' + result <- poppler_annot_text_markup_new_strikeout doc' rect' quadrilaterals'' + checkUnexpectedReturnNULL "annotTextMarkupNewStrikeout" result + result' <- (wrapObject AnnotTextMarkup) result + touchManagedPtr doc + touchManagedPtr rect + mapM_ touchManagedPtr quadrilaterals + unrefGArray quadrilaterals'' + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method AnnotTextMarkup::new_underline +-- method type : Constructor +-- Args : [Arg {argCName = "doc", argType = TInterface (Name {namespace = "Poppler", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rect", argType = TInterface (Name {namespace = "Poppler", name = "Rectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerRectangle", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "quadrilaterals", argType = TGArray (TInterface (Name {namespace = "Poppler", name = "Quadrilateral"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GArray of\n #PopplerQuadrilaterals", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "AnnotTextMarkup"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_annot_text_markup_new_underline" poppler_annot_text_markup_new_underline :: + Ptr Poppler.Document.Document -> -- doc : TInterface (Name {namespace = "Poppler", name = "Document"}) + Ptr Poppler.Rectangle.Rectangle -> -- rect : TInterface (Name {namespace = "Poppler", name = "Rectangle"}) + Ptr (GArray (Ptr Poppler.Quadrilateral.Quadrilateral)) -> -- quadrilaterals : TGArray (TInterface (Name {namespace = "Poppler", name = "Quadrilateral"})) + IO (Ptr AnnotTextMarkup) + +{- | +Creates a new Underline Text annotation that will be +located on /@rect@/ when added to a page. See 'GI.Poppler.Objects.Page.pageAddAnnot' + +/Since: 0.26/ +-} +annotTextMarkupNewUnderline :: + (B.CallStack.HasCallStack, MonadIO m, Poppler.Document.IsDocument a) => + a + {- ^ /@doc@/: a 'GI.Poppler.Objects.Document.Document' -} + -> Poppler.Rectangle.Rectangle + {- ^ /@rect@/: a 'GI.Poppler.Structs.Rectangle.Rectangle' -} + -> [Poppler.Quadrilateral.Quadrilateral] + {- ^ /@quadrilaterals@/: A 'GI.GLib.Structs.Array.Array' of + 'GI.Poppler.Structs.Quadrilateral.Quadrilateral'\s -} + -> m AnnotTextMarkup + {- ^ __Returns:__ A newly created 'GI.Poppler.Objects.AnnotTextMarkup.AnnotTextMarkup' annotation -} +annotTextMarkupNewUnderline doc rect quadrilaterals = liftIO $ do + doc' <- unsafeManagedPtrCastPtr doc + rect' <- unsafeManagedPtrGetPtr rect + quadrilaterals' <- mapM unsafeManagedPtrGetPtr quadrilaterals + quadrilaterals'' <- packGArray quadrilaterals' + result <- poppler_annot_text_markup_new_underline doc' rect' quadrilaterals'' + checkUnexpectedReturnNULL "annotTextMarkupNewUnderline" result + result' <- (wrapObject AnnotTextMarkup) result + touchManagedPtr doc + touchManagedPtr rect + mapM_ touchManagedPtr quadrilaterals + unrefGArray quadrilaterals'' + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method AnnotTextMarkup::get_quadrilaterals +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_annot", argType = TInterface (Name {namespace = "Poppler", name = "AnnotTextMarkup"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerAnnotTextMarkup", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TGArray (TInterface (Name {namespace = "Poppler", name = "Quadrilateral"}))) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_annot_text_markup_get_quadrilaterals" poppler_annot_text_markup_get_quadrilaterals :: + Ptr AnnotTextMarkup -> -- poppler_annot : TInterface (Name {namespace = "Poppler", name = "AnnotTextMarkup"}) + IO (Ptr (GArray (Ptr Poppler.Quadrilateral.Quadrilateral))) + +{- | +Returns a 'GI.GLib.Structs.Array.Array' of 'GI.Poppler.Structs.Quadrilateral.Quadrilateral' items that map from a +location on /@page@/ to a 'GI.Poppler.Objects.AnnotTextMarkup.AnnotTextMarkup'. This array must be freed +when done. + +/Since: 0.26/ +-} +annotTextMarkupGetQuadrilaterals :: + (B.CallStack.HasCallStack, MonadIO m, IsAnnotTextMarkup a) => + a + {- ^ /@popplerAnnot@/: A 'GI.Poppler.Objects.AnnotTextMarkup.AnnotTextMarkup' -} + -> m [Poppler.Quadrilateral.Quadrilateral] + {- ^ __Returns:__ A 'GI.GLib.Structs.Array.Array' of 'GI.Poppler.Structs.Quadrilateral.Quadrilateral' -} +annotTextMarkupGetQuadrilaterals popplerAnnot = liftIO $ do + popplerAnnot' <- unsafeManagedPtrCastPtr popplerAnnot + result <- poppler_annot_text_markup_get_quadrilaterals popplerAnnot' + checkUnexpectedReturnNULL "annotTextMarkupGetQuadrilaterals" result + result' <- unpackGArray result + result'' <- mapM (wrapBoxed Poppler.Quadrilateral.Quadrilateral) result' + unrefGArray result + touchManagedPtr popplerAnnot + return result'' + +#if ENABLE_OVERLOADING +data AnnotTextMarkupGetQuadrilateralsMethodInfo +instance (signature ~ (m [Poppler.Quadrilateral.Quadrilateral]), MonadIO m, IsAnnotTextMarkup a) => O.MethodInfo AnnotTextMarkupGetQuadrilateralsMethodInfo a signature where + overloadedMethod _ = annotTextMarkupGetQuadrilaterals + +#endif + +-- method AnnotTextMarkup::set_quadrilaterals +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_annot", argType = TInterface (Name {namespace = "Poppler", name = "AnnotTextMarkup"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerAnnotTextMarkup", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "quadrilaterals", argType = TGArray (TInterface (Name {namespace = "Poppler", name = "Quadrilateral"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GArray of\n #PopplerQuadrilaterals", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_annot_text_markup_set_quadrilaterals" poppler_annot_text_markup_set_quadrilaterals :: + Ptr AnnotTextMarkup -> -- poppler_annot : TInterface (Name {namespace = "Poppler", name = "AnnotTextMarkup"}) + Ptr (GArray (Ptr Poppler.Quadrilateral.Quadrilateral)) -> -- quadrilaterals : TGArray (TInterface (Name {namespace = "Poppler", name = "Quadrilateral"})) + IO () + +{- | +Set the regions (Quadrilaterals) to apply the text markup in /@popplerAnnot@/. + +/Since: 0.26/ +-} +annotTextMarkupSetQuadrilaterals :: + (B.CallStack.HasCallStack, MonadIO m, IsAnnotTextMarkup a) => + a + {- ^ /@popplerAnnot@/: A 'GI.Poppler.Objects.AnnotTextMarkup.AnnotTextMarkup' -} + -> [Poppler.Quadrilateral.Quadrilateral] + {- ^ /@quadrilaterals@/: A 'GI.GLib.Structs.Array.Array' of + 'GI.Poppler.Structs.Quadrilateral.Quadrilateral'\s -} + -> m () +annotTextMarkupSetQuadrilaterals popplerAnnot quadrilaterals = liftIO $ do + popplerAnnot' <- unsafeManagedPtrCastPtr popplerAnnot + quadrilaterals' <- mapM unsafeManagedPtrGetPtr quadrilaterals + quadrilaterals'' <- packGArray quadrilaterals' + poppler_annot_text_markup_set_quadrilaterals popplerAnnot' quadrilaterals'' + touchManagedPtr popplerAnnot + mapM_ touchManagedPtr quadrilaterals + unrefGArray quadrilaterals'' + return () + +#if ENABLE_OVERLOADING +data AnnotTextMarkupSetQuadrilateralsMethodInfo +instance (signature ~ ([Poppler.Quadrilateral.Quadrilateral] -> m ()), MonadIO m, IsAnnotTextMarkup a) => O.MethodInfo AnnotTextMarkupSetQuadrilateralsMethodInfo a signature where + overloadedMethod _ = annotTextMarkupSetQuadrilaterals + +#endif + + 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,35 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Poppler.Objects.AnnotTextMarkup where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype AnnotTextMarkup = AnnotTextMarkup (ManagedPtr AnnotTextMarkup) +instance GObject AnnotTextMarkup where +class (GObject o, O.IsDescendantOf AnnotTextMarkup o) => IsAnnotTextMarkup o +instance (GObject o, O.IsDescendantOf AnnotTextMarkup o) => IsAnnotTextMarkup o +instance O.HasParentTypes AnnotTextMarkup +#if ENABLE_OVERLOADING +data AnnotTextMarkupGetQuadrilateralsMethodInfo +#endif +#if ENABLE_OVERLOADING +data AnnotTextMarkupSetQuadrilateralsMethodInfo +#endif 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,239 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Poppler.Objects.Attachment + ( + +-- * Exported types + Attachment(..) , + IsAttachment , + toAttachment , + noAttachment , + + + -- * Methods +-- ** save #method:save# + +#if ENABLE_OVERLOADING + AttachmentSaveMethodInfo , +#endif + attachmentSave , + + +-- ** saveToCallback #method:saveToCallback# + +#if ENABLE_OVERLOADING + AttachmentSaveToCallbackMethodInfo , +#endif + attachmentSaveToCallback , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Poppler.Callbacks as Poppler.Callbacks + +-- | Memory-managed wrapper type. +newtype Attachment = Attachment (ManagedPtr Attachment) +foreign import ccall "poppler_attachment_get_type" + c_poppler_attachment_get_type :: IO GType + +instance GObject Attachment where + gobjectType = c_poppler_attachment_get_type + + +-- | Type class for types which can be safely cast to `Attachment`, for instance with `toAttachment`. +class (GObject o, O.IsDescendantOf Attachment o) => IsAttachment o +instance (GObject o, O.IsDescendantOf Attachment o) => IsAttachment o + +instance O.HasParentTypes Attachment +type instance O.ParentTypes Attachment = '[GObject.Object.Object] + +-- | Cast to `Attachment`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toAttachment :: (MonadIO m, IsAttachment o) => o -> m Attachment +toAttachment = liftIO . unsafeCastTo Attachment + +-- | A convenience alias for `Nothing` :: `Maybe` `Attachment`. +noAttachment :: Maybe Attachment +noAttachment = Nothing + +#if ENABLE_OVERLOADING +type family ResolveAttachmentMethod (t :: Symbol) (o :: *) :: * where + ResolveAttachmentMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveAttachmentMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveAttachmentMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveAttachmentMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveAttachmentMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveAttachmentMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveAttachmentMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveAttachmentMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveAttachmentMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveAttachmentMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveAttachmentMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveAttachmentMethod "save" o = AttachmentSaveMethodInfo + ResolveAttachmentMethod "saveToCallback" o = AttachmentSaveToCallbackMethodInfo + ResolveAttachmentMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveAttachmentMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveAttachmentMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveAttachmentMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveAttachmentMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveAttachmentMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveAttachmentMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveAttachmentMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveAttachmentMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveAttachmentMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveAttachmentMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveAttachmentMethod t Attachment, O.MethodInfo info Attachment p) => OL.IsLabel t (Attachment -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList Attachment +type instance O.AttributeList Attachment = AttachmentAttributeList +type AttachmentAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList Attachment = AttachmentSignalList +type AttachmentSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method Attachment::save +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "attachment", argType = TInterface (Name {namespace = "Poppler", name = "Attachment"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerAttachment.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "filename", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "name of file to save", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "poppler_attachment_save" poppler_attachment_save :: + Ptr Attachment -> -- attachment : TInterface (Name {namespace = "Poppler", name = "Attachment"}) + CString -> -- filename : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Saves /@attachment@/ to a file indicated by /@filename@/. If /@error@/ is set, 'False' +will be returned. Possible errors include those in the @/G_FILE_ERROR/@ domain +and whatever the save function generates. +-} +attachmentSave :: + (B.CallStack.HasCallStack, MonadIO m, IsAttachment a) => + a + {- ^ /@attachment@/: A 'GI.Poppler.Objects.Attachment.Attachment'. -} + -> T.Text + {- ^ /@filename@/: name of file to save -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +attachmentSave attachment filename = liftIO $ do + attachment' <- unsafeManagedPtrCastPtr attachment + filename' <- textToCString filename + onException (do + _ <- propagateGError $ poppler_attachment_save attachment' filename' + touchManagedPtr attachment + freeMem filename' + return () + ) (do + freeMem filename' + ) + +#if ENABLE_OVERLOADING +data AttachmentSaveMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsAttachment a) => O.MethodInfo AttachmentSaveMethodInfo a signature where + overloadedMethod _ = attachmentSave + +#endif + +-- method Attachment::save_to_callback +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "attachment", argType = TInterface (Name {namespace = "Poppler", name = "Attachment"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerAttachment.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "save_func", argType = TInterface (Name {namespace = "Poppler", name = "AttachmentSaveFunc"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a function that is called to save each block of data that the save routine generates.", sinceVersion = Nothing}, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data to pass to the save function.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "poppler_attachment_save_to_callback" poppler_attachment_save_to_callback :: + Ptr Attachment -> -- attachment : TInterface (Name {namespace = "Poppler", name = "Attachment"}) + FunPtr Poppler.Callbacks.C_AttachmentSaveFunc -> -- save_func : TInterface (Name {namespace = "Poppler", name = "AttachmentSaveFunc"}) + Ptr () -> -- user_data : TBasicType TPtr + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Saves /@attachment@/ by feeding the produced data to /@saveFunc@/. Can be used +when you want to store the attachment to something other than a file, such as +an in-memory buffer or a socket. If /@error@/ is set, 'False' will be +returned. Possible errors include those in the @/G_FILE_ERROR/@ domain and +whatever the save function generates. +-} +attachmentSaveToCallback :: + (B.CallStack.HasCallStack, MonadIO m, IsAttachment a) => + a + {- ^ /@attachment@/: A 'GI.Poppler.Objects.Attachment.Attachment'. -} + -> FunPtr Poppler.Callbacks.C_AttachmentSaveFunc + {- ^ /@saveFunc@/: a function that is called to save each block of data that the save routine generates. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +attachmentSaveToCallback attachment saveFunc = liftIO $ do + attachment' <- unsafeManagedPtrCastPtr attachment + let userData = nullPtr + onException (do + _ <- propagateGError $ poppler_attachment_save_to_callback attachment' saveFunc userData + safeFreeFunPtr $ castFunPtrToPtr saveFunc + touchManagedPtr attachment + return () + ) (do + safeFreeFunPtr $ castFunPtrToPtr saveFunc + return () + ) + +#if ENABLE_OVERLOADING +data AttachmentSaveToCallbackMethodInfo +instance (signature ~ (FunPtr Poppler.Callbacks.C_AttachmentSaveFunc -> m ()), MonadIO m, IsAttachment a) => O.MethodInfo AttachmentSaveToCallbackMethodInfo a signature where + overloadedMethod _ = attachmentSaveToCallback + +#endif + + 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,35 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Poppler.Objects.Attachment where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype Attachment = Attachment (ManagedPtr Attachment) +instance GObject Attachment where +class (GObject o, O.IsDescendantOf Attachment o) => IsAttachment o +instance (GObject o, O.IsDescendantOf Attachment o) => IsAttachment o +instance O.HasParentTypes Attachment +#if ENABLE_OVERLOADING +data AttachmentSaveMethodInfo +#endif +#if ENABLE_OVERLOADING +data AttachmentSaveToCallbackMethodInfo +#endif 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,3473 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Poppler.Objects.Document + ( + +-- * Exported types + Document(..) , + IsDocument , + toDocument , + noDocument , + + + -- * Methods +-- ** findDest #method:findDest# + +#if ENABLE_OVERLOADING + DocumentFindDestMethodInfo , +#endif + documentFindDest , + + +-- ** getAttachments #method:getAttachments# + +#if ENABLE_OVERLOADING + DocumentGetAttachmentsMethodInfo , +#endif + documentGetAttachments , + + +-- ** getAuthor #method:getAuthor# + +#if ENABLE_OVERLOADING + DocumentGetAuthorMethodInfo , +#endif + documentGetAuthor , + + +-- ** getCreationDate #method:getCreationDate# + +#if ENABLE_OVERLOADING + DocumentGetCreationDateMethodInfo , +#endif + documentGetCreationDate , + + +-- ** getCreator #method:getCreator# + +#if ENABLE_OVERLOADING + DocumentGetCreatorMethodInfo , +#endif + documentGetCreator , + + +-- ** getFormField #method:getFormField# + +#if ENABLE_OVERLOADING + DocumentGetFormFieldMethodInfo , +#endif + documentGetFormField , + + +-- ** getId #method:getId# + +#if ENABLE_OVERLOADING + DocumentGetIdMethodInfo , +#endif + documentGetId , + + +-- ** getKeywords #method:getKeywords# + +#if ENABLE_OVERLOADING + DocumentGetKeywordsMethodInfo , +#endif + documentGetKeywords , + + +-- ** getMetadata #method:getMetadata# + +#if ENABLE_OVERLOADING + DocumentGetMetadataMethodInfo , +#endif + documentGetMetadata , + + +-- ** getModificationDate #method:getModificationDate# + +#if ENABLE_OVERLOADING + DocumentGetModificationDateMethodInfo , +#endif + documentGetModificationDate , + + +-- ** getNAttachments #method:getNAttachments# + +#if ENABLE_OVERLOADING + DocumentGetNAttachmentsMethodInfo , +#endif + documentGetNAttachments , + + +-- ** getNPages #method:getNPages# + +#if ENABLE_OVERLOADING + DocumentGetNPagesMethodInfo , +#endif + documentGetNPages , + + +-- ** getPage #method:getPage# + +#if ENABLE_OVERLOADING + DocumentGetPageMethodInfo , +#endif + documentGetPage , + + +-- ** getPageByLabel #method:getPageByLabel# + +#if ENABLE_OVERLOADING + DocumentGetPageByLabelMethodInfo , +#endif + documentGetPageByLabel , + + +-- ** getPageLayout #method:getPageLayout# + +#if ENABLE_OVERLOADING + DocumentGetPageLayoutMethodInfo , +#endif + documentGetPageLayout , + + +-- ** getPageMode #method:getPageMode# + +#if ENABLE_OVERLOADING + DocumentGetPageModeMethodInfo , +#endif + documentGetPageMode , + + +-- ** getPdfConformance #method:getPdfConformance# + +#if ENABLE_OVERLOADING + DocumentGetPdfConformanceMethodInfo , +#endif + documentGetPdfConformance , + + +-- ** getPdfPart #method:getPdfPart# + +#if ENABLE_OVERLOADING + DocumentGetPdfPartMethodInfo , +#endif + documentGetPdfPart , + + +-- ** getPdfSubtype #method:getPdfSubtype# + +#if ENABLE_OVERLOADING + DocumentGetPdfSubtypeMethodInfo , +#endif + documentGetPdfSubtype , + + +-- ** getPdfSubtypeString #method:getPdfSubtypeString# + +#if ENABLE_OVERLOADING + DocumentGetPdfSubtypeStringMethodInfo , +#endif + documentGetPdfSubtypeString , + + +-- ** getPdfVersion #method:getPdfVersion# + +#if ENABLE_OVERLOADING + DocumentGetPdfVersionMethodInfo , +#endif + documentGetPdfVersion , + + +-- ** getPdfVersionString #method:getPdfVersionString# + +#if ENABLE_OVERLOADING + DocumentGetPdfVersionStringMethodInfo , +#endif + documentGetPdfVersionString , + + +-- ** getPermissions #method:getPermissions# + +#if ENABLE_OVERLOADING + DocumentGetPermissionsMethodInfo , +#endif + documentGetPermissions , + + +-- ** getPrintScaling #method:getPrintScaling# + +#if ENABLE_OVERLOADING + DocumentGetPrintScalingMethodInfo , +#endif + documentGetPrintScaling , + + +-- ** getProducer #method:getProducer# + +#if ENABLE_OVERLOADING + DocumentGetProducerMethodInfo , +#endif + documentGetProducer , + + +-- ** getSubject #method:getSubject# + +#if ENABLE_OVERLOADING + DocumentGetSubjectMethodInfo , +#endif + documentGetSubject , + + +-- ** getTitle #method:getTitle# + +#if ENABLE_OVERLOADING + DocumentGetTitleMethodInfo , +#endif + documentGetTitle , + + +-- ** hasAttachments #method:hasAttachments# + +#if ENABLE_OVERLOADING + DocumentHasAttachmentsMethodInfo , +#endif + documentHasAttachments , + + +-- ** isLinearized #method:isLinearized# + +#if ENABLE_OVERLOADING + DocumentIsLinearizedMethodInfo , +#endif + documentIsLinearized , + + +-- ** newFromData #method:newFromData# + + documentNewFromData , + + +-- ** newFromFile #method:newFromFile# + + documentNewFromFile , + + +-- ** newFromGfile #method:newFromGfile# + + documentNewFromGfile , + + +-- ** newFromStream #method:newFromStream# + + documentNewFromStream , + + +-- ** save #method:save# + +#if ENABLE_OVERLOADING + DocumentSaveMethodInfo , +#endif + documentSave , + + +-- ** saveACopy #method:saveACopy# + +#if ENABLE_OVERLOADING + DocumentSaveACopyMethodInfo , +#endif + documentSaveACopy , + + +-- ** setAuthor #method:setAuthor# + +#if ENABLE_OVERLOADING + DocumentSetAuthorMethodInfo , +#endif + documentSetAuthor , + + +-- ** setCreationDate #method:setCreationDate# + +#if ENABLE_OVERLOADING + DocumentSetCreationDateMethodInfo , +#endif + documentSetCreationDate , + + +-- ** setCreator #method:setCreator# + +#if ENABLE_OVERLOADING + DocumentSetCreatorMethodInfo , +#endif + documentSetCreator , + + +-- ** setKeywords #method:setKeywords# + +#if ENABLE_OVERLOADING + DocumentSetKeywordsMethodInfo , +#endif + documentSetKeywords , + + +-- ** setModificationDate #method:setModificationDate# + +#if ENABLE_OVERLOADING + DocumentSetModificationDateMethodInfo , +#endif + documentSetModificationDate , + + +-- ** setProducer #method:setProducer# + +#if ENABLE_OVERLOADING + DocumentSetProducerMethodInfo , +#endif + documentSetProducer , + + +-- ** setSubject #method:setSubject# + +#if ENABLE_OVERLOADING + DocumentSetSubjectMethodInfo , +#endif + documentSetSubject , + + +-- ** setTitle #method:setTitle# + +#if ENABLE_OVERLOADING + DocumentSetTitleMethodInfo , +#endif + documentSetTitle , + + + + + -- * Properties +-- ** author #attr:author# +{- | The author of the document +-} +#if ENABLE_OVERLOADING + DocumentAuthorPropertyInfo , +#endif + constructDocumentAuthor , +#if ENABLE_OVERLOADING + documentAuthor , +#endif + getDocumentAuthor , + setDocumentAuthor , + + +-- ** creationDate #attr:creationDate# +{- | The date the document was created as seconds since the Epoch, or -1 +-} +#if ENABLE_OVERLOADING + DocumentCreationDatePropertyInfo , +#endif + constructDocumentCreationDate , +#if ENABLE_OVERLOADING + documentCreationDate , +#endif + getDocumentCreationDate , + setDocumentCreationDate , + + +-- ** creator #attr:creator# +{- | The creator of the document. See also 'GI.Poppler.Objects.Document.documentGetCreator' +-} +#if ENABLE_OVERLOADING + DocumentCreatorPropertyInfo , +#endif + constructDocumentCreator , +#if ENABLE_OVERLOADING + documentCreator , +#endif + getDocumentCreator , + setDocumentCreator , + + +-- ** format #attr:format# +{- | The PDF version as string. See also 'GI.Poppler.Objects.Document.documentGetPdfVersionString' +-} +#if ENABLE_OVERLOADING + DocumentFormatPropertyInfo , +#endif +#if ENABLE_OVERLOADING + documentFormat , +#endif + getDocumentFormat , + + +-- ** formatMajor #attr:formatMajor# +{- | The PDF major version number. See also 'GI.Poppler.Objects.Document.documentGetPdfVersion' +-} +#if ENABLE_OVERLOADING + DocumentFormatMajorPropertyInfo , +#endif +#if ENABLE_OVERLOADING + documentFormatMajor , +#endif + getDocumentFormatMajor , + + +-- ** formatMinor #attr:formatMinor# +{- | The PDF minor version number. See also 'GI.Poppler.Objects.Document.documentGetPdfVersion' +-} +#if ENABLE_OVERLOADING + DocumentFormatMinorPropertyInfo , +#endif +#if ENABLE_OVERLOADING + documentFormatMinor , +#endif + getDocumentFormatMinor , + + +-- ** keywords #attr:keywords# +{- | The keywords associated to the document +-} +#if ENABLE_OVERLOADING + DocumentKeywordsPropertyInfo , +#endif + constructDocumentKeywords , +#if ENABLE_OVERLOADING + documentKeywords , +#endif + getDocumentKeywords , + setDocumentKeywords , + + +-- ** linearized #attr:linearized# +{- | Whether document is linearized. See also 'GI.Poppler.Objects.Document.documentIsLinearized' +-} +#if ENABLE_OVERLOADING + DocumentLinearizedPropertyInfo , +#endif +#if ENABLE_OVERLOADING + documentLinearized , +#endif + getDocumentLinearized , + + +-- ** metadata #attr:metadata# +{- | Document metadata in XML format, or 'Nothing' +-} +#if ENABLE_OVERLOADING + DocumentMetadataPropertyInfo , +#endif +#if ENABLE_OVERLOADING + documentMetadata , +#endif + getDocumentMetadata , + + +-- ** modDate #attr:modDate# +{- | The date the document was most recently modified as seconds since the Epoch, or -1 +-} +#if ENABLE_OVERLOADING + DocumentModDatePropertyInfo , +#endif + constructDocumentModDate , +#if ENABLE_OVERLOADING + documentModDate , +#endif + getDocumentModDate , + setDocumentModDate , + + +-- ** pageLayout #attr:pageLayout# +{- | The page layout that should be used when the document is opened +-} +#if ENABLE_OVERLOADING + DocumentPageLayoutPropertyInfo , +#endif +#if ENABLE_OVERLOADING + documentPageLayout , +#endif + getDocumentPageLayout , + + +-- ** pageMode #attr:pageMode# +{- | The mode that should be used when the document is opened +-} +#if ENABLE_OVERLOADING + DocumentPageModePropertyInfo , +#endif +#if ENABLE_OVERLOADING + documentPageMode , +#endif + getDocumentPageMode , + + +-- ** permissions #attr:permissions# +{- | Flags specifying which operations are permitted when the document is opened +-} +#if ENABLE_OVERLOADING + DocumentPermissionsPropertyInfo , +#endif +#if ENABLE_OVERLOADING + documentPermissions , +#endif + getDocumentPermissions , + + +-- ** printScaling #attr:printScaling# +{- | /No description available in the introspection data./ + +/Since: 0.73/ +-} +#if ENABLE_OVERLOADING + DocumentPrintScalingPropertyInfo , +#endif +#if ENABLE_OVERLOADING + documentPrintScaling , +#endif + getDocumentPrintScaling , + + +-- ** producer #attr:producer# +{- | The producer of the document. See also 'GI.Poppler.Objects.Document.documentGetProducer' +-} +#if ENABLE_OVERLOADING + DocumentProducerPropertyInfo , +#endif + constructDocumentProducer , +#if ENABLE_OVERLOADING + documentProducer , +#endif + getDocumentProducer , + setDocumentProducer , + + +-- ** subject #attr:subject# +{- | The subject of the document +-} +#if ENABLE_OVERLOADING + DocumentSubjectPropertyInfo , +#endif + constructDocumentSubject , +#if ENABLE_OVERLOADING + documentSubject , +#endif + getDocumentSubject , + setDocumentSubject , + + +-- ** subtype #attr:subtype# +{- | Document PDF subtype type +-} +#if ENABLE_OVERLOADING + DocumentSubtypePropertyInfo , +#endif +#if ENABLE_OVERLOADING + documentSubtype , +#endif + getDocumentSubtype , + + +-- ** subtypeConformance #attr:subtypeConformance# +{- | Document PDF subtype conformance +-} +#if ENABLE_OVERLOADING + DocumentSubtypeConformancePropertyInfo , +#endif +#if ENABLE_OVERLOADING + documentSubtypeConformance , +#endif + getDocumentSubtypeConformance , + + +-- ** subtypePart #attr:subtypePart# +{- | Document PDF subtype part +-} +#if ENABLE_OVERLOADING + DocumentSubtypePartPropertyInfo , +#endif +#if ENABLE_OVERLOADING + documentSubtypePart , +#endif + getDocumentSubtypePart , + + +-- ** subtypeString #attr:subtypeString# +{- | Document PDF subtype. See also 'GI.Poppler.Objects.Document.documentGetPdfSubtypeString' +-} +#if ENABLE_OVERLOADING + DocumentSubtypeStringPropertyInfo , +#endif +#if ENABLE_OVERLOADING + documentSubtypeString , +#endif + getDocumentSubtypeString , + + +-- ** title #attr:title# +{- | The document\'s title or 'Nothing' +-} +#if ENABLE_OVERLOADING + DocumentTitlePropertyInfo , +#endif + constructDocumentTitle , +#if ENABLE_OVERLOADING + documentTitle , +#endif + getDocumentTitle , + setDocumentTitle , + + +-- ** viewerPreferences #attr:viewerPreferences# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + DocumentViewerPreferencesPropertyInfo , +#endif +#if ENABLE_OVERLOADING + documentViewerPreferences , +#endif + getDocumentViewerPreferences , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Gio.Interfaces.File as Gio.File +import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable +import qualified GI.Gio.Objects.InputStream as Gio.InputStream +import {-# SOURCE #-} qualified GI.Poppler.Enums as Poppler.Enums +import {-# SOURCE #-} qualified GI.Poppler.Flags as Poppler.Flags +import {-# SOURCE #-} qualified GI.Poppler.Objects.Attachment as Poppler.Attachment +import {-# SOURCE #-} qualified GI.Poppler.Objects.FormField as Poppler.FormField +import {-# SOURCE #-} qualified GI.Poppler.Objects.Page as Poppler.Page +import {-# SOURCE #-} qualified GI.Poppler.Structs.Dest as Poppler.Dest + +-- | Memory-managed wrapper type. +newtype Document = Document (ManagedPtr Document) +foreign import ccall "poppler_document_get_type" + c_poppler_document_get_type :: IO GType + +instance GObject Document where + gobjectType = c_poppler_document_get_type + + +-- | Type class for types which can be safely cast to `Document`, for instance with `toDocument`. +class (GObject o, O.IsDescendantOf Document o) => IsDocument o +instance (GObject o, O.IsDescendantOf Document o) => IsDocument o + +instance O.HasParentTypes Document +type instance O.ParentTypes Document = '[GObject.Object.Object] + +-- | Cast to `Document`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toDocument :: (MonadIO m, IsDocument o) => o -> m Document +toDocument = liftIO . unsafeCastTo Document + +-- | A convenience alias for `Nothing` :: `Maybe` `Document`. +noDocument :: Maybe Document +noDocument = Nothing + +#if ENABLE_OVERLOADING +type family ResolveDocumentMethod (t :: Symbol) (o :: *) :: * where + ResolveDocumentMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveDocumentMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveDocumentMethod "findDest" o = DocumentFindDestMethodInfo + ResolveDocumentMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveDocumentMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveDocumentMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveDocumentMethod "hasAttachments" o = DocumentHasAttachmentsMethodInfo + ResolveDocumentMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveDocumentMethod "isLinearized" o = DocumentIsLinearizedMethodInfo + ResolveDocumentMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveDocumentMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveDocumentMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveDocumentMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveDocumentMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveDocumentMethod "save" o = DocumentSaveMethodInfo + ResolveDocumentMethod "saveACopy" o = DocumentSaveACopyMethodInfo + ResolveDocumentMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveDocumentMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveDocumentMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveDocumentMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveDocumentMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveDocumentMethod "getAttachments" o = DocumentGetAttachmentsMethodInfo + ResolveDocumentMethod "getAuthor" o = DocumentGetAuthorMethodInfo + ResolveDocumentMethod "getCreationDate" o = DocumentGetCreationDateMethodInfo + ResolveDocumentMethod "getCreator" o = DocumentGetCreatorMethodInfo + ResolveDocumentMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveDocumentMethod "getFormField" o = DocumentGetFormFieldMethodInfo + ResolveDocumentMethod "getId" o = DocumentGetIdMethodInfo + ResolveDocumentMethod "getKeywords" o = DocumentGetKeywordsMethodInfo + ResolveDocumentMethod "getMetadata" o = DocumentGetMetadataMethodInfo + ResolveDocumentMethod "getModificationDate" o = DocumentGetModificationDateMethodInfo + ResolveDocumentMethod "getNAttachments" o = DocumentGetNAttachmentsMethodInfo + ResolveDocumentMethod "getNPages" o = DocumentGetNPagesMethodInfo + ResolveDocumentMethod "getPage" o = DocumentGetPageMethodInfo + ResolveDocumentMethod "getPageByLabel" o = DocumentGetPageByLabelMethodInfo + ResolveDocumentMethod "getPageLayout" o = DocumentGetPageLayoutMethodInfo + ResolveDocumentMethod "getPageMode" o = DocumentGetPageModeMethodInfo + ResolveDocumentMethod "getPdfConformance" o = DocumentGetPdfConformanceMethodInfo + ResolveDocumentMethod "getPdfPart" o = DocumentGetPdfPartMethodInfo + ResolveDocumentMethod "getPdfSubtype" o = DocumentGetPdfSubtypeMethodInfo + ResolveDocumentMethod "getPdfSubtypeString" o = DocumentGetPdfSubtypeStringMethodInfo + ResolveDocumentMethod "getPdfVersion" o = DocumentGetPdfVersionMethodInfo + ResolveDocumentMethod "getPdfVersionString" o = DocumentGetPdfVersionStringMethodInfo + ResolveDocumentMethod "getPermissions" o = DocumentGetPermissionsMethodInfo + ResolveDocumentMethod "getPrintScaling" o = DocumentGetPrintScalingMethodInfo + ResolveDocumentMethod "getProducer" o = DocumentGetProducerMethodInfo + ResolveDocumentMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveDocumentMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveDocumentMethod "getSubject" o = DocumentGetSubjectMethodInfo + ResolveDocumentMethod "getTitle" o = DocumentGetTitleMethodInfo + ResolveDocumentMethod "setAuthor" o = DocumentSetAuthorMethodInfo + ResolveDocumentMethod "setCreationDate" o = DocumentSetCreationDateMethodInfo + ResolveDocumentMethod "setCreator" o = DocumentSetCreatorMethodInfo + ResolveDocumentMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveDocumentMethod "setKeywords" o = DocumentSetKeywordsMethodInfo + ResolveDocumentMethod "setModificationDate" o = DocumentSetModificationDateMethodInfo + ResolveDocumentMethod "setProducer" o = DocumentSetProducerMethodInfo + ResolveDocumentMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveDocumentMethod "setSubject" o = DocumentSetSubjectMethodInfo + ResolveDocumentMethod "setTitle" o = DocumentSetTitleMethodInfo + ResolveDocumentMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveDocumentMethod t Document, O.MethodInfo info Document p) => OL.IsLabel t (Document -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + +-- VVV Prop "author" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Nothing,Just False) + +{- | +Get the value of the “@author@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' document #author +@ +-} +getDocumentAuthor :: (MonadIO m, IsDocument o) => o -> m (Maybe T.Text) +getDocumentAuthor obj = liftIO $ B.Properties.getObjectPropertyString obj "author" + +{- | +Set the value of the “@author@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' document [ #author 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setDocumentAuthor :: (MonadIO m, IsDocument o) => o -> T.Text -> m () +setDocumentAuthor obj val = liftIO $ B.Properties.setObjectPropertyString obj "author" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@author@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructDocumentAuthor :: (IsDocument o) => T.Text -> IO (GValueConstruct o) +constructDocumentAuthor val = B.Properties.constructObjectPropertyString "author" (Just val) + +#if ENABLE_OVERLOADING +data DocumentAuthorPropertyInfo +instance AttrInfo DocumentAuthorPropertyInfo where + type AttrAllowedOps DocumentAuthorPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint DocumentAuthorPropertyInfo = (~) T.Text + type AttrBaseTypeConstraint DocumentAuthorPropertyInfo = IsDocument + type AttrGetType DocumentAuthorPropertyInfo = (Maybe T.Text) + type AttrLabel DocumentAuthorPropertyInfo = "author" + type AttrOrigin DocumentAuthorPropertyInfo = Document + attrGet _ = getDocumentAuthor + attrSet _ = setDocumentAuthor + attrConstruct _ = constructDocumentAuthor + attrClear _ = undefined +#endif + +-- VVV Prop "creation-date" + -- Type: TBasicType TInt + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@creation-date@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' document #creationDate +@ +-} +getDocumentCreationDate :: (MonadIO m, IsDocument o) => o -> m Int32 +getDocumentCreationDate obj = liftIO $ B.Properties.getObjectPropertyInt32 obj "creation-date" + +{- | +Set the value of the “@creation-date@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' document [ #creationDate 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setDocumentCreationDate :: (MonadIO m, IsDocument o) => o -> Int32 -> m () +setDocumentCreationDate obj val = liftIO $ B.Properties.setObjectPropertyInt32 obj "creation-date" val + +{- | +Construct a `GValueConstruct` with valid value for the “@creation-date@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructDocumentCreationDate :: (IsDocument o) => Int32 -> IO (GValueConstruct o) +constructDocumentCreationDate val = B.Properties.constructObjectPropertyInt32 "creation-date" val + +#if ENABLE_OVERLOADING +data DocumentCreationDatePropertyInfo +instance AttrInfo DocumentCreationDatePropertyInfo where + type AttrAllowedOps DocumentCreationDatePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint DocumentCreationDatePropertyInfo = (~) Int32 + type AttrBaseTypeConstraint DocumentCreationDatePropertyInfo = IsDocument + type AttrGetType DocumentCreationDatePropertyInfo = Int32 + type AttrLabel DocumentCreationDatePropertyInfo = "creation-date" + type AttrOrigin DocumentCreationDatePropertyInfo = Document + attrGet _ = getDocumentCreationDate + attrSet _ = setDocumentCreationDate + attrConstruct _ = constructDocumentCreationDate + attrClear _ = undefined +#endif + +-- VVV Prop "creator" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Nothing,Just False) + +{- | +Get the value of the “@creator@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' document #creator +@ +-} +getDocumentCreator :: (MonadIO m, IsDocument o) => o -> m (Maybe T.Text) +getDocumentCreator obj = liftIO $ B.Properties.getObjectPropertyString obj "creator" + +{- | +Set the value of the “@creator@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' document [ #creator 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setDocumentCreator :: (MonadIO m, IsDocument o) => o -> T.Text -> m () +setDocumentCreator obj val = liftIO $ B.Properties.setObjectPropertyString obj "creator" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@creator@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructDocumentCreator :: (IsDocument o) => T.Text -> IO (GValueConstruct o) +constructDocumentCreator val = B.Properties.constructObjectPropertyString "creator" (Just val) + +#if ENABLE_OVERLOADING +data DocumentCreatorPropertyInfo +instance AttrInfo DocumentCreatorPropertyInfo where + type AttrAllowedOps DocumentCreatorPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint DocumentCreatorPropertyInfo = (~) T.Text + type AttrBaseTypeConstraint DocumentCreatorPropertyInfo = IsDocument + type AttrGetType DocumentCreatorPropertyInfo = (Maybe T.Text) + type AttrLabel DocumentCreatorPropertyInfo = "creator" + type AttrOrigin DocumentCreatorPropertyInfo = Document + attrGet _ = getDocumentCreator + attrSet _ = setDocumentCreator + attrConstruct _ = constructDocumentCreator + attrClear _ = undefined +#endif + +-- VVV Prop "format" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@format@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' document #format +@ +-} +getDocumentFormat :: (MonadIO m, IsDocument o) => o -> m (Maybe T.Text) +getDocumentFormat obj = liftIO $ B.Properties.getObjectPropertyString obj "format" + +#if ENABLE_OVERLOADING +data DocumentFormatPropertyInfo +instance AttrInfo DocumentFormatPropertyInfo where + type AttrAllowedOps DocumentFormatPropertyInfo = '[ 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint DocumentFormatPropertyInfo = (~) () + type AttrBaseTypeConstraint DocumentFormatPropertyInfo = IsDocument + type AttrGetType DocumentFormatPropertyInfo = (Maybe T.Text) + type AttrLabel DocumentFormatPropertyInfo = "format" + type AttrOrigin DocumentFormatPropertyInfo = Document + attrGet _ = getDocumentFormat + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- VVV Prop "format-major" + -- Type: TBasicType TUInt + -- Flags: [PropertyReadable] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@format-major@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' document #formatMajor +@ +-} +getDocumentFormatMajor :: (MonadIO m, IsDocument o) => o -> m Word32 +getDocumentFormatMajor obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "format-major" + +#if ENABLE_OVERLOADING +data DocumentFormatMajorPropertyInfo +instance AttrInfo DocumentFormatMajorPropertyInfo where + type AttrAllowedOps DocumentFormatMajorPropertyInfo = '[ 'AttrGet] + type AttrSetTypeConstraint DocumentFormatMajorPropertyInfo = (~) () + type AttrBaseTypeConstraint DocumentFormatMajorPropertyInfo = IsDocument + type AttrGetType DocumentFormatMajorPropertyInfo = Word32 + type AttrLabel DocumentFormatMajorPropertyInfo = "format-major" + type AttrOrigin DocumentFormatMajorPropertyInfo = Document + attrGet _ = getDocumentFormatMajor + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- VVV Prop "format-minor" + -- Type: TBasicType TUInt + -- Flags: [PropertyReadable] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@format-minor@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' document #formatMinor +@ +-} +getDocumentFormatMinor :: (MonadIO m, IsDocument o) => o -> m Word32 +getDocumentFormatMinor obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "format-minor" + +#if ENABLE_OVERLOADING +data DocumentFormatMinorPropertyInfo +instance AttrInfo DocumentFormatMinorPropertyInfo where + type AttrAllowedOps DocumentFormatMinorPropertyInfo = '[ 'AttrGet] + type AttrSetTypeConstraint DocumentFormatMinorPropertyInfo = (~) () + type AttrBaseTypeConstraint DocumentFormatMinorPropertyInfo = IsDocument + type AttrGetType DocumentFormatMinorPropertyInfo = Word32 + type AttrLabel DocumentFormatMinorPropertyInfo = "format-minor" + type AttrOrigin DocumentFormatMinorPropertyInfo = Document + attrGet _ = getDocumentFormatMinor + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- VVV Prop "keywords" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Nothing,Just False) + +{- | +Get the value of the “@keywords@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' document #keywords +@ +-} +getDocumentKeywords :: (MonadIO m, IsDocument o) => o -> m (Maybe T.Text) +getDocumentKeywords obj = liftIO $ B.Properties.getObjectPropertyString obj "keywords" + +{- | +Set the value of the “@keywords@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' document [ #keywords 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setDocumentKeywords :: (MonadIO m, IsDocument o) => o -> T.Text -> m () +setDocumentKeywords obj val = liftIO $ B.Properties.setObjectPropertyString obj "keywords" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@keywords@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructDocumentKeywords :: (IsDocument o) => T.Text -> IO (GValueConstruct o) +constructDocumentKeywords val = B.Properties.constructObjectPropertyString "keywords" (Just val) + +#if ENABLE_OVERLOADING +data DocumentKeywordsPropertyInfo +instance AttrInfo DocumentKeywordsPropertyInfo where + type AttrAllowedOps DocumentKeywordsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint DocumentKeywordsPropertyInfo = (~) T.Text + type AttrBaseTypeConstraint DocumentKeywordsPropertyInfo = IsDocument + type AttrGetType DocumentKeywordsPropertyInfo = (Maybe T.Text) + type AttrLabel DocumentKeywordsPropertyInfo = "keywords" + type AttrOrigin DocumentKeywordsPropertyInfo = Document + attrGet _ = getDocumentKeywords + attrSet _ = setDocumentKeywords + attrConstruct _ = constructDocumentKeywords + attrClear _ = undefined +#endif + +-- VVV Prop "linearized" + -- Type: TBasicType TBoolean + -- Flags: [PropertyReadable] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@linearized@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' document #linearized +@ +-} +getDocumentLinearized :: (MonadIO m, IsDocument o) => o -> m Bool +getDocumentLinearized obj = liftIO $ B.Properties.getObjectPropertyBool obj "linearized" + +#if ENABLE_OVERLOADING +data DocumentLinearizedPropertyInfo +instance AttrInfo DocumentLinearizedPropertyInfo where + type AttrAllowedOps DocumentLinearizedPropertyInfo = '[ 'AttrGet] + type AttrSetTypeConstraint DocumentLinearizedPropertyInfo = (~) () + type AttrBaseTypeConstraint DocumentLinearizedPropertyInfo = IsDocument + type AttrGetType DocumentLinearizedPropertyInfo = Bool + type AttrLabel DocumentLinearizedPropertyInfo = "linearized" + type AttrOrigin DocumentLinearizedPropertyInfo = Document + attrGet _ = getDocumentLinearized + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- VVV Prop "metadata" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@metadata@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' document #metadata +@ +-} +getDocumentMetadata :: (MonadIO m, IsDocument o) => o -> m (Maybe T.Text) +getDocumentMetadata obj = liftIO $ B.Properties.getObjectPropertyString obj "metadata" + +#if ENABLE_OVERLOADING +data DocumentMetadataPropertyInfo +instance AttrInfo DocumentMetadataPropertyInfo where + type AttrAllowedOps DocumentMetadataPropertyInfo = '[ 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint DocumentMetadataPropertyInfo = (~) () + type AttrBaseTypeConstraint DocumentMetadataPropertyInfo = IsDocument + type AttrGetType DocumentMetadataPropertyInfo = (Maybe T.Text) + type AttrLabel DocumentMetadataPropertyInfo = "metadata" + type AttrOrigin DocumentMetadataPropertyInfo = Document + attrGet _ = getDocumentMetadata + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- VVV Prop "mod-date" + -- Type: TBasicType TInt + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@mod-date@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' document #modDate +@ +-} +getDocumentModDate :: (MonadIO m, IsDocument o) => o -> m Int32 +getDocumentModDate obj = liftIO $ B.Properties.getObjectPropertyInt32 obj "mod-date" + +{- | +Set the value of the “@mod-date@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' document [ #modDate 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setDocumentModDate :: (MonadIO m, IsDocument o) => o -> Int32 -> m () +setDocumentModDate obj val = liftIO $ B.Properties.setObjectPropertyInt32 obj "mod-date" val + +{- | +Construct a `GValueConstruct` with valid value for the “@mod-date@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructDocumentModDate :: (IsDocument o) => Int32 -> IO (GValueConstruct o) +constructDocumentModDate val = B.Properties.constructObjectPropertyInt32 "mod-date" val + +#if ENABLE_OVERLOADING +data DocumentModDatePropertyInfo +instance AttrInfo DocumentModDatePropertyInfo where + type AttrAllowedOps DocumentModDatePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint DocumentModDatePropertyInfo = (~) Int32 + type AttrBaseTypeConstraint DocumentModDatePropertyInfo = IsDocument + type AttrGetType DocumentModDatePropertyInfo = Int32 + type AttrLabel DocumentModDatePropertyInfo = "mod-date" + type AttrOrigin DocumentModDatePropertyInfo = Document + attrGet _ = getDocumentModDate + attrSet _ = setDocumentModDate + attrConstruct _ = constructDocumentModDate + attrClear _ = undefined +#endif + +-- VVV Prop "page-layout" + -- Type: TInterface (Name {namespace = "Poppler", name = "PageLayout"}) + -- Flags: [PropertyReadable] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@page-layout@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' document #pageLayout +@ +-} +getDocumentPageLayout :: (MonadIO m, IsDocument o) => o -> m Poppler.Enums.PageLayout +getDocumentPageLayout obj = liftIO $ B.Properties.getObjectPropertyEnum obj "page-layout" + +#if ENABLE_OVERLOADING +data DocumentPageLayoutPropertyInfo +instance AttrInfo DocumentPageLayoutPropertyInfo where + type AttrAllowedOps DocumentPageLayoutPropertyInfo = '[ 'AttrGet] + type AttrSetTypeConstraint DocumentPageLayoutPropertyInfo = (~) () + type AttrBaseTypeConstraint DocumentPageLayoutPropertyInfo = IsDocument + type AttrGetType DocumentPageLayoutPropertyInfo = Poppler.Enums.PageLayout + type AttrLabel DocumentPageLayoutPropertyInfo = "page-layout" + type AttrOrigin DocumentPageLayoutPropertyInfo = Document + attrGet _ = getDocumentPageLayout + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- VVV Prop "page-mode" + -- Type: TInterface (Name {namespace = "Poppler", name = "PageMode"}) + -- Flags: [PropertyReadable] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@page-mode@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' document #pageMode +@ +-} +getDocumentPageMode :: (MonadIO m, IsDocument o) => o -> m Poppler.Enums.PageMode +getDocumentPageMode obj = liftIO $ B.Properties.getObjectPropertyEnum obj "page-mode" + +#if ENABLE_OVERLOADING +data DocumentPageModePropertyInfo +instance AttrInfo DocumentPageModePropertyInfo where + type AttrAllowedOps DocumentPageModePropertyInfo = '[ 'AttrGet] + type AttrSetTypeConstraint DocumentPageModePropertyInfo = (~) () + type AttrBaseTypeConstraint DocumentPageModePropertyInfo = IsDocument + type AttrGetType DocumentPageModePropertyInfo = Poppler.Enums.PageMode + type AttrLabel DocumentPageModePropertyInfo = "page-mode" + type AttrOrigin DocumentPageModePropertyInfo = Document + attrGet _ = getDocumentPageMode + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- VVV Prop "permissions" + -- Type: TInterface (Name {namespace = "Poppler", name = "Permissions"}) + -- Flags: [PropertyReadable] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@permissions@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' document #permissions +@ +-} +getDocumentPermissions :: (MonadIO m, IsDocument o) => o -> m [Poppler.Flags.Permissions] +getDocumentPermissions obj = liftIO $ B.Properties.getObjectPropertyFlags obj "permissions" + +#if ENABLE_OVERLOADING +data DocumentPermissionsPropertyInfo +instance AttrInfo DocumentPermissionsPropertyInfo where + type AttrAllowedOps DocumentPermissionsPropertyInfo = '[ 'AttrGet] + type AttrSetTypeConstraint DocumentPermissionsPropertyInfo = (~) () + type AttrBaseTypeConstraint DocumentPermissionsPropertyInfo = IsDocument + type AttrGetType DocumentPermissionsPropertyInfo = [Poppler.Flags.Permissions] + type AttrLabel DocumentPermissionsPropertyInfo = "permissions" + type AttrOrigin DocumentPermissionsPropertyInfo = Document + attrGet _ = getDocumentPermissions + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- VVV Prop "print-scaling" + -- Type: TInterface (Name {namespace = "Poppler", name = "PrintScaling"}) + -- Flags: [PropertyReadable] + -- Nullable: (Just False,Nothing) + +{- | +Get the value of the “@print-scaling@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' document #printScaling +@ +-} +getDocumentPrintScaling :: (MonadIO m, IsDocument o) => o -> m Poppler.Enums.PrintScaling +getDocumentPrintScaling obj = liftIO $ B.Properties.getObjectPropertyEnum obj "print-scaling" + +#if ENABLE_OVERLOADING +data DocumentPrintScalingPropertyInfo +instance AttrInfo DocumentPrintScalingPropertyInfo where + type AttrAllowedOps DocumentPrintScalingPropertyInfo = '[ 'AttrGet] + type AttrSetTypeConstraint DocumentPrintScalingPropertyInfo = (~) () + type AttrBaseTypeConstraint DocumentPrintScalingPropertyInfo = IsDocument + type AttrGetType DocumentPrintScalingPropertyInfo = Poppler.Enums.PrintScaling + type AttrLabel DocumentPrintScalingPropertyInfo = "print-scaling" + type AttrOrigin DocumentPrintScalingPropertyInfo = Document + attrGet _ = getDocumentPrintScaling + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- VVV Prop "producer" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Nothing,Just False) + +{- | +Get the value of the “@producer@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' document #producer +@ +-} +getDocumentProducer :: (MonadIO m, IsDocument o) => o -> m (Maybe T.Text) +getDocumentProducer obj = liftIO $ B.Properties.getObjectPropertyString obj "producer" + +{- | +Set the value of the “@producer@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' document [ #producer 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setDocumentProducer :: (MonadIO m, IsDocument o) => o -> T.Text -> m () +setDocumentProducer obj val = liftIO $ B.Properties.setObjectPropertyString obj "producer" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@producer@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructDocumentProducer :: (IsDocument o) => T.Text -> IO (GValueConstruct o) +constructDocumentProducer val = B.Properties.constructObjectPropertyString "producer" (Just val) + +#if ENABLE_OVERLOADING +data DocumentProducerPropertyInfo +instance AttrInfo DocumentProducerPropertyInfo where + type AttrAllowedOps DocumentProducerPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint DocumentProducerPropertyInfo = (~) T.Text + type AttrBaseTypeConstraint DocumentProducerPropertyInfo = IsDocument + type AttrGetType DocumentProducerPropertyInfo = (Maybe T.Text) + type AttrLabel DocumentProducerPropertyInfo = "producer" + type AttrOrigin DocumentProducerPropertyInfo = Document + attrGet _ = getDocumentProducer + attrSet _ = setDocumentProducer + attrConstruct _ = constructDocumentProducer + attrClear _ = undefined +#endif + +-- VVV Prop "subject" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Nothing,Just False) + +{- | +Get the value of the “@subject@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' document #subject +@ +-} +getDocumentSubject :: (MonadIO m, IsDocument o) => o -> m (Maybe T.Text) +getDocumentSubject obj = liftIO $ B.Properties.getObjectPropertyString obj "subject" + +{- | +Set the value of the “@subject@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' document [ #subject 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setDocumentSubject :: (MonadIO m, IsDocument o) => o -> T.Text -> m () +setDocumentSubject obj val = liftIO $ B.Properties.setObjectPropertyString obj "subject" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@subject@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructDocumentSubject :: (IsDocument o) => T.Text -> IO (GValueConstruct o) +constructDocumentSubject val = B.Properties.constructObjectPropertyString "subject" (Just val) + +#if ENABLE_OVERLOADING +data DocumentSubjectPropertyInfo +instance AttrInfo DocumentSubjectPropertyInfo where + type AttrAllowedOps DocumentSubjectPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint DocumentSubjectPropertyInfo = (~) T.Text + type AttrBaseTypeConstraint DocumentSubjectPropertyInfo = IsDocument + type AttrGetType DocumentSubjectPropertyInfo = (Maybe T.Text) + type AttrLabel DocumentSubjectPropertyInfo = "subject" + type AttrOrigin DocumentSubjectPropertyInfo = Document + attrGet _ = getDocumentSubject + attrSet _ = setDocumentSubject + attrConstruct _ = constructDocumentSubject + attrClear _ = undefined +#endif + +-- VVV Prop "subtype" + -- Type: TInterface (Name {namespace = "Poppler", name = "PDFSubtype"}) + -- Flags: [PropertyReadable] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@subtype@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' document #subtype +@ +-} +getDocumentSubtype :: (MonadIO m, IsDocument o) => o -> m Poppler.Enums.PDFSubtype +getDocumentSubtype obj = liftIO $ B.Properties.getObjectPropertyEnum obj "subtype" + +#if ENABLE_OVERLOADING +data DocumentSubtypePropertyInfo +instance AttrInfo DocumentSubtypePropertyInfo where + type AttrAllowedOps DocumentSubtypePropertyInfo = '[ 'AttrGet] + type AttrSetTypeConstraint DocumentSubtypePropertyInfo = (~) () + type AttrBaseTypeConstraint DocumentSubtypePropertyInfo = IsDocument + type AttrGetType DocumentSubtypePropertyInfo = Poppler.Enums.PDFSubtype + type AttrLabel DocumentSubtypePropertyInfo = "subtype" + type AttrOrigin DocumentSubtypePropertyInfo = Document + attrGet _ = getDocumentSubtype + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- VVV Prop "subtype-conformance" + -- Type: TInterface (Name {namespace = "Poppler", name = "PDFConformance"}) + -- Flags: [PropertyReadable] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@subtype-conformance@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' document #subtypeConformance +@ +-} +getDocumentSubtypeConformance :: (MonadIO m, IsDocument o) => o -> m Poppler.Enums.PDFConformance +getDocumentSubtypeConformance obj = liftIO $ B.Properties.getObjectPropertyEnum obj "subtype-conformance" + +#if ENABLE_OVERLOADING +data DocumentSubtypeConformancePropertyInfo +instance AttrInfo DocumentSubtypeConformancePropertyInfo where + type AttrAllowedOps DocumentSubtypeConformancePropertyInfo = '[ 'AttrGet] + type AttrSetTypeConstraint DocumentSubtypeConformancePropertyInfo = (~) () + type AttrBaseTypeConstraint DocumentSubtypeConformancePropertyInfo = IsDocument + type AttrGetType DocumentSubtypeConformancePropertyInfo = Poppler.Enums.PDFConformance + type AttrLabel DocumentSubtypeConformancePropertyInfo = "subtype-conformance" + type AttrOrigin DocumentSubtypeConformancePropertyInfo = Document + attrGet _ = getDocumentSubtypeConformance + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- VVV Prop "subtype-part" + -- Type: TInterface (Name {namespace = "Poppler", name = "PDFPart"}) + -- Flags: [PropertyReadable] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@subtype-part@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' document #subtypePart +@ +-} +getDocumentSubtypePart :: (MonadIO m, IsDocument o) => o -> m Poppler.Enums.PDFPart +getDocumentSubtypePart obj = liftIO $ B.Properties.getObjectPropertyEnum obj "subtype-part" + +#if ENABLE_OVERLOADING +data DocumentSubtypePartPropertyInfo +instance AttrInfo DocumentSubtypePartPropertyInfo where + type AttrAllowedOps DocumentSubtypePartPropertyInfo = '[ 'AttrGet] + type AttrSetTypeConstraint DocumentSubtypePartPropertyInfo = (~) () + type AttrBaseTypeConstraint DocumentSubtypePartPropertyInfo = IsDocument + type AttrGetType DocumentSubtypePartPropertyInfo = Poppler.Enums.PDFPart + type AttrLabel DocumentSubtypePartPropertyInfo = "subtype-part" + type AttrOrigin DocumentSubtypePartPropertyInfo = Document + attrGet _ = getDocumentSubtypePart + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- VVV Prop "subtype-string" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@subtype-string@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' document #subtypeString +@ +-} +getDocumentSubtypeString :: (MonadIO m, IsDocument o) => o -> m (Maybe T.Text) +getDocumentSubtypeString obj = liftIO $ B.Properties.getObjectPropertyString obj "subtype-string" + +#if ENABLE_OVERLOADING +data DocumentSubtypeStringPropertyInfo +instance AttrInfo DocumentSubtypeStringPropertyInfo where + type AttrAllowedOps DocumentSubtypeStringPropertyInfo = '[ 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint DocumentSubtypeStringPropertyInfo = (~) () + type AttrBaseTypeConstraint DocumentSubtypeStringPropertyInfo = IsDocument + type AttrGetType DocumentSubtypeStringPropertyInfo = (Maybe T.Text) + type AttrLabel DocumentSubtypeStringPropertyInfo = "subtype-string" + type AttrOrigin DocumentSubtypeStringPropertyInfo = Document + attrGet _ = getDocumentSubtypeString + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +-- VVV Prop "title" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable,PropertyWritable] + -- Nullable: (Nothing,Just False) + +{- | +Get the value of the “@title@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' document #title +@ +-} +getDocumentTitle :: (MonadIO m, IsDocument o) => o -> m (Maybe T.Text) +getDocumentTitle obj = liftIO $ B.Properties.getObjectPropertyString obj "title" + +{- | +Set the value of the “@title@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' document [ #title 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setDocumentTitle :: (MonadIO m, IsDocument o) => o -> T.Text -> m () +setDocumentTitle obj val = liftIO $ B.Properties.setObjectPropertyString obj "title" (Just val) + +{- | +Construct a `GValueConstruct` with valid value for the “@title@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructDocumentTitle :: (IsDocument o) => T.Text -> IO (GValueConstruct o) +constructDocumentTitle val = B.Properties.constructObjectPropertyString "title" (Just val) + +#if ENABLE_OVERLOADING +data DocumentTitlePropertyInfo +instance AttrInfo DocumentTitlePropertyInfo where + type AttrAllowedOps DocumentTitlePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint DocumentTitlePropertyInfo = (~) T.Text + type AttrBaseTypeConstraint DocumentTitlePropertyInfo = IsDocument + type AttrGetType DocumentTitlePropertyInfo = (Maybe T.Text) + type AttrLabel DocumentTitlePropertyInfo = "title" + type AttrOrigin DocumentTitlePropertyInfo = Document + attrGet _ = getDocumentTitle + attrSet _ = setDocumentTitle + attrConstruct _ = constructDocumentTitle + attrClear _ = undefined +#endif + +-- VVV Prop "viewer-preferences" + -- Type: TInterface (Name {namespace = "Poppler", name = "ViewerPreferences"}) + -- Flags: [PropertyReadable] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@viewer-preferences@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' document #viewerPreferences +@ +-} +getDocumentViewerPreferences :: (MonadIO m, IsDocument o) => o -> m [Poppler.Flags.ViewerPreferences] +getDocumentViewerPreferences obj = liftIO $ B.Properties.getObjectPropertyFlags obj "viewer-preferences" + +#if ENABLE_OVERLOADING +data DocumentViewerPreferencesPropertyInfo +instance AttrInfo DocumentViewerPreferencesPropertyInfo where + type AttrAllowedOps DocumentViewerPreferencesPropertyInfo = '[ 'AttrGet] + type AttrSetTypeConstraint DocumentViewerPreferencesPropertyInfo = (~) () + type AttrBaseTypeConstraint DocumentViewerPreferencesPropertyInfo = IsDocument + type AttrGetType DocumentViewerPreferencesPropertyInfo = [Poppler.Flags.ViewerPreferences] + type AttrLabel DocumentViewerPreferencesPropertyInfo = "viewer-preferences" + type AttrOrigin DocumentViewerPreferencesPropertyInfo = Document + attrGet _ = getDocumentViewerPreferences + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList Document +type instance O.AttributeList Document = DocumentAttributeList +type DocumentAttributeList = ('[ '("author", DocumentAuthorPropertyInfo), '("creationDate", DocumentCreationDatePropertyInfo), '("creator", DocumentCreatorPropertyInfo), '("format", DocumentFormatPropertyInfo), '("formatMajor", DocumentFormatMajorPropertyInfo), '("formatMinor", DocumentFormatMinorPropertyInfo), '("keywords", DocumentKeywordsPropertyInfo), '("linearized", DocumentLinearizedPropertyInfo), '("metadata", DocumentMetadataPropertyInfo), '("modDate", DocumentModDatePropertyInfo), '("pageLayout", DocumentPageLayoutPropertyInfo), '("pageMode", DocumentPageModePropertyInfo), '("permissions", DocumentPermissionsPropertyInfo), '("printScaling", DocumentPrintScalingPropertyInfo), '("producer", DocumentProducerPropertyInfo), '("subject", DocumentSubjectPropertyInfo), '("subtype", DocumentSubtypePropertyInfo), '("subtypeConformance", DocumentSubtypeConformancePropertyInfo), '("subtypePart", DocumentSubtypePartPropertyInfo), '("subtypeString", DocumentSubtypeStringPropertyInfo), '("title", DocumentTitlePropertyInfo), '("viewerPreferences", DocumentViewerPreferencesPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +documentAuthor :: AttrLabelProxy "author" +documentAuthor = AttrLabelProxy + +documentCreationDate :: AttrLabelProxy "creationDate" +documentCreationDate = AttrLabelProxy + +documentCreator :: AttrLabelProxy "creator" +documentCreator = AttrLabelProxy + +documentFormat :: AttrLabelProxy "format" +documentFormat = AttrLabelProxy + +documentFormatMajor :: AttrLabelProxy "formatMajor" +documentFormatMajor = AttrLabelProxy + +documentFormatMinor :: AttrLabelProxy "formatMinor" +documentFormatMinor = AttrLabelProxy + +documentKeywords :: AttrLabelProxy "keywords" +documentKeywords = AttrLabelProxy + +documentLinearized :: AttrLabelProxy "linearized" +documentLinearized = AttrLabelProxy + +documentMetadata :: AttrLabelProxy "metadata" +documentMetadata = AttrLabelProxy + +documentModDate :: AttrLabelProxy "modDate" +documentModDate = AttrLabelProxy + +documentPageLayout :: AttrLabelProxy "pageLayout" +documentPageLayout = AttrLabelProxy + +documentPageMode :: AttrLabelProxy "pageMode" +documentPageMode = AttrLabelProxy + +documentPermissions :: AttrLabelProxy "permissions" +documentPermissions = AttrLabelProxy + +documentPrintScaling :: AttrLabelProxy "printScaling" +documentPrintScaling = AttrLabelProxy + +documentProducer :: AttrLabelProxy "producer" +documentProducer = AttrLabelProxy + +documentSubject :: AttrLabelProxy "subject" +documentSubject = AttrLabelProxy + +documentSubtype :: AttrLabelProxy "subtype" +documentSubtype = AttrLabelProxy + +documentSubtypeConformance :: AttrLabelProxy "subtypeConformance" +documentSubtypeConformance = AttrLabelProxy + +documentSubtypePart :: AttrLabelProxy "subtypePart" +documentSubtypePart = AttrLabelProxy + +documentSubtypeString :: AttrLabelProxy "subtypeString" +documentSubtypeString = AttrLabelProxy + +documentTitle :: AttrLabelProxy "title" +documentTitle = AttrLabelProxy + +documentViewerPreferences :: AttrLabelProxy "viewerPreferences" +documentViewerPreferences = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList Document = DocumentSignalList +type DocumentSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method Document::new_from_data +-- method type : Constructor +-- Args : [Arg {argCName = "data", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the pdf data contained in a char array", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "length", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the length of #data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "password", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "password to unlock the file with, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "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 TInt + CString -> -- password : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO (Ptr Document) + +{- | +Creates a new 'GI.Poppler.Objects.Document.Document'. If 'Nothing' is returned, then /@error@/ will be +set. Possible errors include those in the @/POPPLER_ERROR/@ and @/G_FILE_ERROR/@ +domains. +-} +documentNewFromData :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + {- ^ /@data@/: the pdf data contained in a char array -} + -> Int32 + {- ^ /@length@/: the length of @/data/@ -} + -> Maybe (T.Text) + {- ^ /@password@/: password to unlock the file with, or 'Nothing' -} + -> m Document + {- ^ __Returns:__ A newly created 'GI.Poppler.Objects.Document.Document', or 'Nothing' /(Can throw 'Data.GI.Base.GError.GError')/ -} +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 "documentNewFromData" result + result' <- (wrapObject Document) result + freeMem data_' + freeMem maybePassword + return result' + ) (do + freeMem data_' + freeMem maybePassword + ) + +#if ENABLE_OVERLOADING +#endif + +-- method Document::new_from_file +-- method type : Constructor +-- Args : [Arg {argCName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "uri of the file to load", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "password", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "password to unlock the file with, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "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) + +{- | +Creates a new 'GI.Poppler.Objects.Document.Document'. If 'Nothing' is returned, then /@error@/ will be +set. Possible errors include those in the @/POPPLER_ERROR/@ and @/G_FILE_ERROR/@ +domains. +-} +documentNewFromFile :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + {- ^ /@uri@/: uri of the file to load -} + -> Maybe (T.Text) + {- ^ /@password@/: password to unlock the file with, or 'Nothing' -} + -> m Document + {- ^ __Returns:__ A newly created 'GI.Poppler.Objects.Document.Document', or 'Nothing' /(Can throw 'Data.GI.Base.GError.GError')/ -} +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 "documentNewFromFile" result + result' <- (wrapObject Document) result + freeMem uri' + freeMem maybePassword + return result' + ) (do + freeMem uri' + freeMem maybePassword + ) + +#if ENABLE_OVERLOADING +#endif + +-- method Document::new_from_gfile +-- method type : Constructor +-- Args : [Arg {argCName = "file", argType = TInterface (Name {namespace = "Gio", name = "File"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GFile to load", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "password", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "password to unlock the file with, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "Document"})) +-- throws : True +-- Skip return : False + +foreign import ccall "poppler_document_new_from_gfile" poppler_document_new_from_gfile :: + Ptr Gio.File.File -> -- file : TInterface (Name {namespace = "Gio", name = "File"}) + CString -> -- password : TBasicType TUTF8 + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Document) + +{- | +Creates a new 'GI.Poppler.Objects.Document.Document' reading the PDF contents from /@file@/. +Possible errors include those in the @/POPPLER_ERROR/@ and @/G_FILE_ERROR/@ +domains. + +/Since: 0.22/ +-} +documentNewFromGfile :: + (B.CallStack.HasCallStack, MonadIO m, Gio.File.IsFile a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@file@/: a 'GI.Gio.Interfaces.File.File' to load -} + -> Maybe (T.Text) + {- ^ /@password@/: password to unlock the file with, or 'Nothing' -} + -> Maybe (b) + {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable', or 'Nothing' -} + -> m Document + {- ^ __Returns:__ a new 'GI.Poppler.Objects.Document.Document', or 'Nothing' /(Can throw 'Data.GI.Base.GError.GError')/ -} +documentNewFromGfile file password cancellable = liftIO $ do + 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 + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + result <- propagateGError $ poppler_document_new_from_gfile file' maybePassword maybeCancellable + checkUnexpectedReturnNULL "documentNewFromGfile" result + result' <- (wrapObject Document) result + touchManagedPtr file + whenJust cancellable touchManagedPtr + freeMem maybePassword + return result' + ) (do + freeMem maybePassword + ) + +#if ENABLE_OVERLOADING +#endif + +-- method Document::new_from_stream +-- method type : Constructor +-- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "InputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GInputStream to read from", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "length", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the stream length, or -1 if not known", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "password", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "password to unlock the file with, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "Document"})) +-- throws : True +-- Skip return : False + +foreign import ccall "poppler_document_new_from_stream" poppler_document_new_from_stream :: + Ptr Gio.InputStream.InputStream -> -- stream : TInterface (Name {namespace = "Gio", name = "InputStream"}) + Int64 -> -- length : TBasicType TInt64 + CString -> -- password : TBasicType TUTF8 + Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) + Ptr (Ptr GError) -> -- error + IO (Ptr Document) + +{- | +Creates a new 'GI.Poppler.Objects.Document.Document' reading the PDF contents from /@stream@/. +Note that the given 'GI.Gio.Objects.InputStream.InputStream' must be seekable or 'GI.Gio.Enums.IOErrorEnumNotSupported' +will be returned. +Possible errors include those in the @/POPPLER_ERROR/@ and @/G_FILE_ERROR/@ +domains. + +/Since: 0.22/ +-} +documentNewFromStream :: + (B.CallStack.HasCallStack, MonadIO m, Gio.InputStream.IsInputStream a, Gio.Cancellable.IsCancellable b) => + a + {- ^ /@stream@/: a 'GI.Gio.Objects.InputStream.InputStream' to read from -} + -> Int64 + {- ^ /@length@/: the stream length, or -1 if not known -} + -> Maybe (T.Text) + {- ^ /@password@/: password to unlock the file with, or 'Nothing' -} + -> Maybe (b) + {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable', or 'Nothing' -} + -> m Document + {- ^ __Returns:__ a new 'GI.Poppler.Objects.Document.Document', or 'Nothing' /(Can throw 'Data.GI.Base.GError.GError')/ -} +documentNewFromStream stream length_ password cancellable = liftIO $ do + 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 + jCancellable' <- unsafeManagedPtrCastPtr jCancellable + return jCancellable' + onException (do + result <- propagateGError $ poppler_document_new_from_stream stream' length_ maybePassword maybeCancellable + checkUnexpectedReturnNULL "documentNewFromStream" result + result' <- (wrapObject Document) result + touchManagedPtr stream + whenJust cancellable touchManagedPtr + freeMem maybePassword + return result' + ) (do + freeMem maybePassword + ) + +#if ENABLE_OVERLOADING +#endif + +-- method Document::find_dest +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "document", argType = TInterface (Name {namespace = "Poppler", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "link_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a named destination", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "Dest"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_document_find_dest" poppler_document_find_dest :: + Ptr Document -> -- document : TInterface (Name {namespace = "Poppler", name = "Document"}) + CString -> -- link_name : TBasicType TUTF8 + IO (Ptr Poppler.Dest.Dest) + +{- | +Creates a 'GI.Poppler.Structs.Dest.Dest' for the named destination /@linkName@/ in /@document@/. + +Note that named destinations are bytestrings, not string. That means that +unless /@linkName@/ was returned by a poppler function (e.g. is +'GI.Poppler.Structs.Dest.Dest'.@/named_dest/@), it needs to be converted to string +using 'GI.Poppler.Functions.namedDestFromBytestring' before being passed to this +function. + +The returned value must be freed with 'GI.Poppler.Structs.Dest.destFree'. +-} +documentFindDest :: + (B.CallStack.HasCallStack, MonadIO m, IsDocument a) => + a + {- ^ /@document@/: A 'GI.Poppler.Objects.Document.Document' -} + -> T.Text + {- ^ /@linkName@/: a named destination -} + -> m Poppler.Dest.Dest + {- ^ __Returns:__ a new 'GI.Poppler.Structs.Dest.Dest' destination, or 'Nothing' if + /@linkName@/ is not a destination. -} +documentFindDest document linkName = liftIO $ do + document' <- unsafeManagedPtrCastPtr document + linkName' <- textToCString linkName + result <- poppler_document_find_dest document' linkName' + checkUnexpectedReturnNULL "documentFindDest" result + result' <- (wrapBoxed Poppler.Dest.Dest) result + touchManagedPtr document + freeMem linkName' + return result' + +#if ENABLE_OVERLOADING +data DocumentFindDestMethodInfo +instance (signature ~ (T.Text -> m Poppler.Dest.Dest), MonadIO m, IsDocument a) => O.MethodInfo DocumentFindDestMethodInfo a signature where + overloadedMethod _ = documentFindDest + +#endif + +-- method Document::get_attachments +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "document", argType = TInterface (Name {namespace = "Poppler", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TGList (TInterface (Name {namespace = "Poppler", name = "Attachment"}))) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_document_get_attachments" poppler_document_get_attachments :: + Ptr Document -> -- document : TInterface (Name {namespace = "Poppler", name = "Document"}) + IO (Ptr (GList (Ptr Poppler.Attachment.Attachment))) + +{- | +Returns a 'GI.GLib.Structs.List.List' containing 'GI.Poppler.Objects.Attachment.Attachment'\s. These attachments +are unowned, and must be unreffed, and the list must be freed with +@/g_list_free()/@. +-} +documentGetAttachments :: + (B.CallStack.HasCallStack, MonadIO m, IsDocument a) => + a + {- ^ /@document@/: A 'GI.Poppler.Objects.Document.Document' -} + -> m [Poppler.Attachment.Attachment] + {- ^ __Returns:__ a list of available attachments. -} +documentGetAttachments document = liftIO $ do + document' <- unsafeManagedPtrCastPtr document + result <- poppler_document_get_attachments document' + result' <- unpackGList result + result'' <- mapM (wrapObject Poppler.Attachment.Attachment) result' + g_list_free result + touchManagedPtr document + return result'' + +#if ENABLE_OVERLOADING +data DocumentGetAttachmentsMethodInfo +instance (signature ~ (m [Poppler.Attachment.Attachment]), MonadIO m, IsDocument a) => O.MethodInfo DocumentGetAttachmentsMethodInfo a signature where + overloadedMethod _ = documentGetAttachments + +#endif + +-- method Document::get_author +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "document", argType = TInterface (Name {namespace = "Poppler", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_document_get_author" poppler_document_get_author :: + Ptr Document -> -- document : TInterface (Name {namespace = "Poppler", name = "Document"}) + IO CString + +{- | +Returns the author of the document + +/Since: 0.16/ +-} +documentGetAuthor :: + (B.CallStack.HasCallStack, MonadIO m, IsDocument a) => + a + {- ^ /@document@/: A 'GI.Poppler.Objects.Document.Document' -} + -> m T.Text + {- ^ __Returns:__ a new allocated string containing the author + of /@document@/, or 'Nothing' -} +documentGetAuthor document = liftIO $ do + document' <- unsafeManagedPtrCastPtr document + result <- poppler_document_get_author document' + checkUnexpectedReturnNULL "documentGetAuthor" result + result' <- cstringToText result + freeMem result + touchManagedPtr document + return result' + +#if ENABLE_OVERLOADING +data DocumentGetAuthorMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsDocument a) => O.MethodInfo DocumentGetAuthorMethodInfo a signature where + overloadedMethod _ = documentGetAuthor + +#endif + +-- method Document::get_creation_date +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "document", argType = TInterface (Name {namespace = "Poppler", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TLong) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_document_get_creation_date" poppler_document_get_creation_date :: + Ptr Document -> -- document : TInterface (Name {namespace = "Poppler", name = "Document"}) + IO CLong + +{- | +Returns the date the document was created as seconds since the Epoch + +/Since: 0.16/ +-} +documentGetCreationDate :: + (B.CallStack.HasCallStack, MonadIO m, IsDocument a) => + a + {- ^ /@document@/: A 'GI.Poppler.Objects.Document.Document' -} + -> m CLong + {- ^ __Returns:__ the date the document was created, or -1 -} +documentGetCreationDate document = liftIO $ do + document' <- unsafeManagedPtrCastPtr document + result <- poppler_document_get_creation_date document' + touchManagedPtr document + return result + +#if ENABLE_OVERLOADING +data DocumentGetCreationDateMethodInfo +instance (signature ~ (m CLong), MonadIO m, IsDocument a) => O.MethodInfo DocumentGetCreationDateMethodInfo a signature where + overloadedMethod _ = documentGetCreationDate + +#endif + +-- method Document::get_creator +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "document", argType = TInterface (Name {namespace = "Poppler", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_document_get_creator" poppler_document_get_creator :: + Ptr Document -> -- document : TInterface (Name {namespace = "Poppler", name = "Document"}) + IO CString + +{- | +Returns the creator of the document. If the document was converted +from another format, the creator is the name of the product +that created the original document from which it was converted. + +/Since: 0.16/ +-} +documentGetCreator :: + (B.CallStack.HasCallStack, MonadIO m, IsDocument a) => + a + {- ^ /@document@/: A 'GI.Poppler.Objects.Document.Document' -} + -> m T.Text + {- ^ __Returns:__ a new allocated string containing the creator + of /@document@/, or 'Nothing' -} +documentGetCreator document = liftIO $ do + document' <- unsafeManagedPtrCastPtr document + result <- poppler_document_get_creator document' + checkUnexpectedReturnNULL "documentGetCreator" result + result' <- cstringToText result + freeMem result + touchManagedPtr document + return result' + +#if ENABLE_OVERLOADING +data DocumentGetCreatorMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsDocument a) => O.MethodInfo DocumentGetCreatorMethodInfo a signature where + overloadedMethod _ = documentGetCreator + +#endif + +-- method Document::get_form_field +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "document", argType = TInterface (Name {namespace = "Poppler", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "id", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an id of a #PopplerFormField", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "FormField"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_document_get_form_field" poppler_document_get_form_field :: + Ptr Document -> -- document : TInterface (Name {namespace = "Poppler", name = "Document"}) + Int32 -> -- id : TBasicType TInt + IO (Ptr Poppler.FormField.FormField) + +{- | +Returns the 'GI.Poppler.Objects.FormField.FormField' for the given /@id@/. It must be freed with +'GI.GObject.Objects.Object.objectUnref' +-} +documentGetFormField :: + (B.CallStack.HasCallStack, MonadIO m, IsDocument a) => + a + {- ^ /@document@/: a 'GI.Poppler.Objects.Document.Document' -} + -> Int32 + {- ^ /@id@/: an id of a 'GI.Poppler.Objects.FormField.FormField' -} + -> m Poppler.FormField.FormField + {- ^ __Returns:__ a new 'GI.Poppler.Objects.FormField.FormField' or 'Nothing' if +not found -} +documentGetFormField document id = liftIO $ do + document' <- unsafeManagedPtrCastPtr document + result <- poppler_document_get_form_field document' id + checkUnexpectedReturnNULL "documentGetFormField" result + result' <- (wrapObject Poppler.FormField.FormField) result + touchManagedPtr document + return result' + +#if ENABLE_OVERLOADING +data DocumentGetFormFieldMethodInfo +instance (signature ~ (Int32 -> m Poppler.FormField.FormField), MonadIO m, IsDocument a) => O.MethodInfo DocumentGetFormFieldMethodInfo a signature where + overloadedMethod _ = documentGetFormField + +#endif + +-- method Document::get_id +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "document", argType = TInterface (Name {namespace = "Poppler", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "permanent_id", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store an allocated string, use g_free() to free the returned string", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "update_id", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store an allocated string, use g_free() to free the returned string", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_document_get_id" poppler_document_get_id :: + Ptr Document -> -- document : TInterface (Name {namespace = "Poppler", name = "Document"}) + Ptr CString -> -- permanent_id : TBasicType TUTF8 + Ptr CString -> -- update_id : TBasicType TUTF8 + IO CInt + +{- | +Returns the PDF file identifier represented as two byte string arrays of size 32. +/@permanentId@/ is the permanent identifier that is built based on the file +contents at the time it was originally created, so that this identifer +never changes. /@updateId@/ is the update identifier that is built based on +the file contents at the time it was last updated. + +Note that returned strings are not null-terminated, they have a fixed +size of 32 bytes. + +/Since: 0.16/ +-} +documentGetId :: + (B.CallStack.HasCallStack, MonadIO m, IsDocument a) => + a + {- ^ /@document@/: A 'GI.Poppler.Objects.Document.Document' -} + -> m ((Bool, T.Text, T.Text)) + {- ^ __Returns:__ 'True' if the /@document@/ contains an id, 'False' otherwise -} +documentGetId document = liftIO $ do + document' <- unsafeManagedPtrCastPtr document + permanentId <- allocMem :: IO (Ptr CString) + updateId <- allocMem :: IO (Ptr CString) + result <- poppler_document_get_id document' permanentId updateId + let result' = (/= 0) result + permanentId' <- peek permanentId + permanentId'' <- cstringToText permanentId' + freeMem permanentId' + updateId' <- peek updateId + updateId'' <- cstringToText updateId' + freeMem updateId' + touchManagedPtr document + freeMem permanentId + freeMem updateId + return (result', permanentId'', updateId'') + +#if ENABLE_OVERLOADING +data DocumentGetIdMethodInfo +instance (signature ~ (m ((Bool, T.Text, T.Text))), MonadIO m, IsDocument a) => O.MethodInfo DocumentGetIdMethodInfo a signature where + overloadedMethod _ = documentGetId + +#endif + +-- method Document::get_keywords +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "document", argType = TInterface (Name {namespace = "Poppler", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_document_get_keywords" poppler_document_get_keywords :: + Ptr Document -> -- document : TInterface (Name {namespace = "Poppler", name = "Document"}) + IO CString + +{- | +Returns the keywords associated to the document + +/Since: 0.16/ +-} +documentGetKeywords :: + (B.CallStack.HasCallStack, MonadIO m, IsDocument a) => + a + {- ^ /@document@/: A 'GI.Poppler.Objects.Document.Document' -} + -> m T.Text + {- ^ __Returns:__ a new allocated string containing keywords associated + to /@document@/, or 'Nothing' -} +documentGetKeywords document = liftIO $ do + document' <- unsafeManagedPtrCastPtr document + result <- poppler_document_get_keywords document' + checkUnexpectedReturnNULL "documentGetKeywords" result + result' <- cstringToText result + freeMem result + touchManagedPtr document + return result' + +#if ENABLE_OVERLOADING +data DocumentGetKeywordsMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsDocument a) => O.MethodInfo DocumentGetKeywordsMethodInfo a signature where + overloadedMethod _ = documentGetKeywords + +#endif + +-- method Document::get_metadata +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "document", argType = TInterface (Name {namespace = "Poppler", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_document_get_metadata" poppler_document_get_metadata :: + Ptr Document -> -- document : TInterface (Name {namespace = "Poppler", name = "Document"}) + IO CString + +{- | +Returns the XML metadata string of the document + +/Since: 0.16/ +-} +documentGetMetadata :: + (B.CallStack.HasCallStack, MonadIO m, IsDocument a) => + a + {- ^ /@document@/: A 'GI.Poppler.Objects.Document.Document' -} + -> m T.Text + {- ^ __Returns:__ a new allocated string containing the XML + metadata, or 'Nothing' -} +documentGetMetadata document = liftIO $ do + document' <- unsafeManagedPtrCastPtr document + result <- poppler_document_get_metadata document' + checkUnexpectedReturnNULL "documentGetMetadata" result + result' <- cstringToText result + freeMem result + touchManagedPtr document + return result' + +#if ENABLE_OVERLOADING +data DocumentGetMetadataMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsDocument a) => O.MethodInfo DocumentGetMetadataMethodInfo a signature where + overloadedMethod _ = documentGetMetadata + +#endif + +-- method Document::get_modification_date +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "document", argType = TInterface (Name {namespace = "Poppler", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TLong) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_document_get_modification_date" poppler_document_get_modification_date :: + Ptr Document -> -- document : TInterface (Name {namespace = "Poppler", name = "Document"}) + IO CLong + +{- | +Returns the date the document was most recently modified as seconds since the Epoch + +/Since: 0.16/ +-} +documentGetModificationDate :: + (B.CallStack.HasCallStack, MonadIO m, IsDocument a) => + a + {- ^ /@document@/: A 'GI.Poppler.Objects.Document.Document' -} + -> m CLong + {- ^ __Returns:__ the date the document was most recently modified, or -1 -} +documentGetModificationDate document = liftIO $ do + document' <- unsafeManagedPtrCastPtr document + result <- poppler_document_get_modification_date document' + touchManagedPtr document + return result + +#if ENABLE_OVERLOADING +data DocumentGetModificationDateMethodInfo +instance (signature ~ (m CLong), MonadIO m, IsDocument a) => O.MethodInfo DocumentGetModificationDateMethodInfo a signature where + overloadedMethod _ = documentGetModificationDate + +#endif + +-- method Document::get_n_attachments +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "document", argType = TInterface (Name {namespace = "Poppler", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_document_get_n_attachments" poppler_document_get_n_attachments :: + Ptr Document -> -- document : TInterface (Name {namespace = "Poppler", name = "Document"}) + IO Word32 + +{- | +Returns the number of attachments in a loaded document. +See also 'GI.Poppler.Objects.Document.documentGetAttachments' + +/Since: 0.18/ +-} +documentGetNAttachments :: + (B.CallStack.HasCallStack, MonadIO m, IsDocument a) => + a + {- ^ /@document@/: A 'GI.Poppler.Objects.Document.Document' -} + -> m Word32 + {- ^ __Returns:__ Number of attachments -} +documentGetNAttachments document = liftIO $ do + document' <- unsafeManagedPtrCastPtr document + result <- poppler_document_get_n_attachments document' + touchManagedPtr document + return result + +#if ENABLE_OVERLOADING +data DocumentGetNAttachmentsMethodInfo +instance (signature ~ (m Word32), MonadIO m, IsDocument a) => O.MethodInfo DocumentGetNAttachmentsMethodInfo a signature where + overloadedMethod _ = documentGetNAttachments + +#endif + +-- method Document::get_n_pages +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "document", argType = TInterface (Name {namespace = "Poppler", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_document_get_n_pages" poppler_document_get_n_pages :: + Ptr Document -> -- document : TInterface (Name {namespace = "Poppler", name = "Document"}) + IO Int32 + +{- | +Returns the number of pages in a loaded document. +-} +documentGetNPages :: + (B.CallStack.HasCallStack, MonadIO m, IsDocument a) => + a + {- ^ /@document@/: A 'GI.Poppler.Objects.Document.Document' -} + -> m Int32 + {- ^ __Returns:__ Number of pages -} +documentGetNPages document = liftIO $ do + document' <- unsafeManagedPtrCastPtr document + result <- poppler_document_get_n_pages document' + touchManagedPtr document + return result + +#if ENABLE_OVERLOADING +data DocumentGetNPagesMethodInfo +instance (signature ~ (m Int32), MonadIO m, IsDocument a) => O.MethodInfo DocumentGetNPagesMethodInfo a signature where + overloadedMethod _ = documentGetNPages + +#endif + +-- method Document::get_page +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "document", argType = TInterface (Name {namespace = "Poppler", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a page index", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "Page"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_document_get_page" poppler_document_get_page :: + Ptr Document -> -- document : TInterface (Name {namespace = "Poppler", name = "Document"}) + Int32 -> -- index : TBasicType TInt + IO (Ptr Poppler.Page.Page) + +{- | +Returns the 'GI.Poppler.Objects.Page.Page' indexed at /@index@/. This object is owned by the +caller. +-} +documentGetPage :: + (B.CallStack.HasCallStack, MonadIO m, IsDocument a) => + a + {- ^ /@document@/: A 'GI.Poppler.Objects.Document.Document' -} + -> Int32 + {- ^ /@index@/: a page index -} + -> m Poppler.Page.Page + {- ^ __Returns:__ The 'GI.Poppler.Objects.Page.Page' at /@index@/ -} +documentGetPage document index = liftIO $ do + document' <- unsafeManagedPtrCastPtr document + result <- poppler_document_get_page document' index + checkUnexpectedReturnNULL "documentGetPage" result + result' <- (wrapObject Poppler.Page.Page) result + touchManagedPtr document + return result' + +#if ENABLE_OVERLOADING +data DocumentGetPageMethodInfo +instance (signature ~ (Int32 -> m Poppler.Page.Page), MonadIO m, IsDocument a) => O.MethodInfo DocumentGetPageMethodInfo a signature where + overloadedMethod _ = documentGetPage + +#endif + +-- method Document::get_page_by_label +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "document", argType = TInterface (Name {namespace = "Poppler", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a page label", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "Page"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_document_get_page_by_label" poppler_document_get_page_by_label :: + Ptr Document -> -- document : TInterface (Name {namespace = "Poppler", name = "Document"}) + CString -> -- label : TBasicType TUTF8 + IO (Ptr Poppler.Page.Page) + +{- | +Returns the 'GI.Poppler.Objects.Page.Page' reference by /@label@/. This object is owned by the +caller. /@label@/ is a human-readable string representation of the page number, +and can be document specific. Typically, it is a value such as \"iii\" or \"3\". + +By default, \"1\" refers to the first page. +-} +documentGetPageByLabel :: + (B.CallStack.HasCallStack, MonadIO m, IsDocument a) => + a + {- ^ /@document@/: A 'GI.Poppler.Objects.Document.Document' -} + -> T.Text + {- ^ /@label@/: a page label -} + -> m Poppler.Page.Page + {- ^ __Returns:__ The 'GI.Poppler.Objects.Page.Page' referenced by /@label@/ -} +documentGetPageByLabel document label = liftIO $ do + document' <- unsafeManagedPtrCastPtr document + label' <- textToCString label + result <- poppler_document_get_page_by_label document' label' + checkUnexpectedReturnNULL "documentGetPageByLabel" result + result' <- (wrapObject Poppler.Page.Page) result + touchManagedPtr document + freeMem label' + return result' + +#if ENABLE_OVERLOADING +data DocumentGetPageByLabelMethodInfo +instance (signature ~ (T.Text -> m Poppler.Page.Page), MonadIO m, IsDocument a) => O.MethodInfo DocumentGetPageByLabelMethodInfo a signature where + overloadedMethod _ = documentGetPageByLabel + +#endif + +-- method Document::get_page_layout +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "document", argType = TInterface (Name {namespace = "Poppler", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "PageLayout"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_document_get_page_layout" poppler_document_get_page_layout :: + Ptr Document -> -- document : TInterface (Name {namespace = "Poppler", name = "Document"}) + IO CUInt + +{- | +Returns the page layout that should be used when the document is opened + +/Since: 0.16/ +-} +documentGetPageLayout :: + (B.CallStack.HasCallStack, MonadIO m, IsDocument a) => + a + {- ^ /@document@/: A 'GI.Poppler.Objects.Document.Document' -} + -> m Poppler.Enums.PageLayout + {- ^ __Returns:__ a 'GI.Poppler.Enums.PageLayout' that should be used when the document is opened -} +documentGetPageLayout document = liftIO $ do + document' <- unsafeManagedPtrCastPtr document + result <- poppler_document_get_page_layout document' + let result' = (toEnum . fromIntegral) result + touchManagedPtr document + return result' + +#if ENABLE_OVERLOADING +data DocumentGetPageLayoutMethodInfo +instance (signature ~ (m Poppler.Enums.PageLayout), MonadIO m, IsDocument a) => O.MethodInfo DocumentGetPageLayoutMethodInfo a signature where + overloadedMethod _ = documentGetPageLayout + +#endif + +-- method Document::get_page_mode +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "document", argType = TInterface (Name {namespace = "Poppler", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "PageMode"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_document_get_page_mode" poppler_document_get_page_mode :: + Ptr Document -> -- document : TInterface (Name {namespace = "Poppler", name = "Document"}) + IO CUInt + +{- | +Returns a 'GI.Poppler.Enums.PageMode' representing how the document should +be initially displayed when opened. + +/Since: 0.16/ +-} +documentGetPageMode :: + (B.CallStack.HasCallStack, MonadIO m, IsDocument a) => + a + {- ^ /@document@/: A 'GI.Poppler.Objects.Document.Document' -} + -> m Poppler.Enums.PageMode + {- ^ __Returns:__ a 'GI.Poppler.Enums.PageMode' that should be used when document is opened -} +documentGetPageMode document = liftIO $ do + document' <- unsafeManagedPtrCastPtr document + result <- poppler_document_get_page_mode document' + let result' = (toEnum . fromIntegral) result + touchManagedPtr document + return result' + +#if ENABLE_OVERLOADING +data DocumentGetPageModeMethodInfo +instance (signature ~ (m Poppler.Enums.PageMode), MonadIO m, IsDocument a) => O.MethodInfo DocumentGetPageModeMethodInfo a signature where + overloadedMethod _ = documentGetPageMode + +#endif + +-- method Document::get_pdf_conformance +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "document", argType = TInterface (Name {namespace = "Poppler", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "PDFConformance"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_document_get_pdf_conformance" poppler_document_get_pdf_conformance :: + Ptr Document -> -- document : TInterface (Name {namespace = "Poppler", name = "Document"}) + IO CUInt + +{- | +Returns the conformance level of the /@document@/ as 'GI.Poppler.Enums.PDFConformance'. + +/Since: 0.70/ +-} +documentGetPdfConformance :: + (B.CallStack.HasCallStack, MonadIO m, IsDocument a) => + a + {- ^ /@document@/: A 'GI.Poppler.Objects.Document.Document' -} + -> m Poppler.Enums.PDFConformance + {- ^ __Returns:__ the document\'s subtype conformance level -} +documentGetPdfConformance document = liftIO $ do + document' <- unsafeManagedPtrCastPtr document + result <- poppler_document_get_pdf_conformance document' + let result' = (toEnum . fromIntegral) result + touchManagedPtr document + return result' + +#if ENABLE_OVERLOADING +data DocumentGetPdfConformanceMethodInfo +instance (signature ~ (m Poppler.Enums.PDFConformance), MonadIO m, IsDocument a) => O.MethodInfo DocumentGetPdfConformanceMethodInfo a signature where + overloadedMethod _ = documentGetPdfConformance + +#endif + +-- method Document::get_pdf_part +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "document", argType = TInterface (Name {namespace = "Poppler", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "PDFPart"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_document_get_pdf_part" poppler_document_get_pdf_part :: + Ptr Document -> -- document : TInterface (Name {namespace = "Poppler", name = "Document"}) + IO CUInt + +{- | +Returns the part of the conforming standard that the /@document@/ adheres to +as a 'GI.Poppler.Enums.PDFSubtype'. + +/Since: 0.70/ +-} +documentGetPdfPart :: + (B.CallStack.HasCallStack, MonadIO m, IsDocument a) => + a + {- ^ /@document@/: A 'GI.Poppler.Objects.Document.Document' -} + -> m Poppler.Enums.PDFPart + {- ^ __Returns:__ the document\'s subtype part -} +documentGetPdfPart document = liftIO $ do + document' <- unsafeManagedPtrCastPtr document + result <- poppler_document_get_pdf_part document' + let result' = (toEnum . fromIntegral) result + touchManagedPtr document + return result' + +#if ENABLE_OVERLOADING +data DocumentGetPdfPartMethodInfo +instance (signature ~ (m Poppler.Enums.PDFPart), MonadIO m, IsDocument a) => O.MethodInfo DocumentGetPdfPartMethodInfo a signature where + overloadedMethod _ = documentGetPdfPart + +#endif + +-- method Document::get_pdf_subtype +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "document", argType = TInterface (Name {namespace = "Poppler", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "PDFSubtype"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_document_get_pdf_subtype" poppler_document_get_pdf_subtype :: + Ptr Document -> -- document : TInterface (Name {namespace = "Poppler", name = "Document"}) + IO CUInt + +{- | +Returns the subtype of /@document@/ as a 'GI.Poppler.Enums.PDFSubtype'. + +/Since: 0.70/ +-} +documentGetPdfSubtype :: + (B.CallStack.HasCallStack, MonadIO m, IsDocument a) => + a + {- ^ /@document@/: A 'GI.Poppler.Objects.Document.Document' -} + -> m Poppler.Enums.PDFSubtype + {- ^ __Returns:__ the document\'s subtype -} +documentGetPdfSubtype document = liftIO $ do + document' <- unsafeManagedPtrCastPtr document + result <- poppler_document_get_pdf_subtype document' + let result' = (toEnum . fromIntegral) result + touchManagedPtr document + return result' + +#if ENABLE_OVERLOADING +data DocumentGetPdfSubtypeMethodInfo +instance (signature ~ (m Poppler.Enums.PDFSubtype), MonadIO m, IsDocument a) => O.MethodInfo DocumentGetPdfSubtypeMethodInfo a signature where + overloadedMethod _ = documentGetPdfSubtype + +#endif + +-- method Document::get_pdf_subtype_string +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "document", argType = TInterface (Name {namespace = "Poppler", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_document_get_pdf_subtype_string" poppler_document_get_pdf_subtype_string :: + Ptr Document -> -- document : TInterface (Name {namespace = "Poppler", name = "Document"}) + IO CString + +{- | +Returns the PDF subtype version of /@document@/ as a string. + +/Since: 0.70/ +-} +documentGetPdfSubtypeString :: + (B.CallStack.HasCallStack, MonadIO m, IsDocument a) => + a + {- ^ /@document@/: A 'GI.Poppler.Objects.Document.Document' -} + -> m (Maybe T.Text) + {- ^ __Returns:__ a newly allocated string containing +the PDF subtype version of /@document@/, or 'Nothing' -} +documentGetPdfSubtypeString document = liftIO $ do + document' <- unsafeManagedPtrCastPtr document + result <- poppler_document_get_pdf_subtype_string document' + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- cstringToText result' + freeMem result' + return result'' + touchManagedPtr document + return maybeResult + +#if ENABLE_OVERLOADING +data DocumentGetPdfSubtypeStringMethodInfo +instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsDocument a) => O.MethodInfo DocumentGetPdfSubtypeStringMethodInfo a signature where + overloadedMethod _ = documentGetPdfSubtypeString + +#endif + +-- method Document::get_pdf_version +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "document", argType = TInterface (Name {namespace = "Poppler", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "major_version", argType = TBasicType TUInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the PDF major version number", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "minor_version", argType = TBasicType TUInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the PDF minor version number", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_document_get_pdf_version" poppler_document_get_pdf_version :: + Ptr Document -> -- document : TInterface (Name {namespace = "Poppler", name = "Document"}) + Ptr Word32 -> -- major_version : TBasicType TUInt + Ptr Word32 -> -- minor_version : TBasicType TUInt + IO () + +{- | +/No description available in the introspection data./ + +/Since: 0.16/ +-} +documentGetPdfVersion :: + (B.CallStack.HasCallStack, MonadIO m, IsDocument a) => + a + {- ^ /@document@/: A 'GI.Poppler.Objects.Document.Document' -} + -> m ((Word32, Word32)) +documentGetPdfVersion document = liftIO $ do + document' <- unsafeManagedPtrCastPtr document + majorVersion <- allocMem :: IO (Ptr Word32) + minorVersion <- allocMem :: IO (Ptr Word32) + poppler_document_get_pdf_version document' majorVersion minorVersion + majorVersion' <- peek majorVersion + minorVersion' <- peek minorVersion + touchManagedPtr document + freeMem majorVersion + freeMem minorVersion + return (majorVersion', minorVersion') + +#if ENABLE_OVERLOADING +data DocumentGetPdfVersionMethodInfo +instance (signature ~ (m ((Word32, Word32))), MonadIO m, IsDocument a) => O.MethodInfo DocumentGetPdfVersionMethodInfo a signature where + overloadedMethod _ = documentGetPdfVersion + +#endif + +-- method Document::get_pdf_version_string +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "document", argType = TInterface (Name {namespace = "Poppler", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_document_get_pdf_version_string" poppler_document_get_pdf_version_string :: + Ptr Document -> -- document : TInterface (Name {namespace = "Poppler", name = "Document"}) + IO CString + +{- | +Returns the PDF version of /@document@/ as a string (e.g. PDF-1.6) + +/Since: 0.16/ +-} +documentGetPdfVersionString :: + (B.CallStack.HasCallStack, MonadIO m, IsDocument a) => + a + {- ^ /@document@/: A 'GI.Poppler.Objects.Document.Document' -} + -> m T.Text + {- ^ __Returns:__ a new allocated string containing the PDF version + of /@document@/, or 'Nothing' -} +documentGetPdfVersionString document = liftIO $ do + document' <- unsafeManagedPtrCastPtr document + result <- poppler_document_get_pdf_version_string document' + checkUnexpectedReturnNULL "documentGetPdfVersionString" result + result' <- cstringToText result + freeMem result + touchManagedPtr document + return result' + +#if ENABLE_OVERLOADING +data DocumentGetPdfVersionStringMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsDocument a) => O.MethodInfo DocumentGetPdfVersionStringMethodInfo a signature where + overloadedMethod _ = documentGetPdfVersionString + +#endif + +-- method Document::get_permissions +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "document", argType = TInterface (Name {namespace = "Poppler", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "Permissions"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_document_get_permissions" poppler_document_get_permissions :: + Ptr Document -> -- document : TInterface (Name {namespace = "Poppler", name = "Document"}) + IO CUInt + +{- | +Returns the flags specifying which operations are permitted when the document is opened. + +/Since: 0.16/ +-} +documentGetPermissions :: + (B.CallStack.HasCallStack, MonadIO m, IsDocument a) => + a + {- ^ /@document@/: A 'GI.Poppler.Objects.Document.Document' -} + -> m [Poppler.Flags.Permissions] + {- ^ __Returns:__ a set of flags from 'GI.Poppler.Flags.Permissions' enumeration -} +documentGetPermissions document = liftIO $ do + document' <- unsafeManagedPtrCastPtr document + result <- poppler_document_get_permissions document' + let result' = wordToGFlags result + touchManagedPtr document + return result' + +#if ENABLE_OVERLOADING +data DocumentGetPermissionsMethodInfo +instance (signature ~ (m [Poppler.Flags.Permissions]), MonadIO m, IsDocument a) => O.MethodInfo DocumentGetPermissionsMethodInfo a signature where + overloadedMethod _ = documentGetPermissions + +#endif + +-- method Document::get_print_scaling +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "document", argType = TInterface (Name {namespace = "Poppler", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "PrintScaling"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_document_get_print_scaling" poppler_document_get_print_scaling :: + Ptr Document -> -- document : TInterface (Name {namespace = "Poppler", name = "Document"}) + IO CUInt + +{- | +Returns the print scaling value suggested by author of the document. + +/Since: 0.73/ +-} +documentGetPrintScaling :: + (B.CallStack.HasCallStack, MonadIO m, IsDocument a) => + a + {- ^ /@document@/: A 'GI.Poppler.Objects.Document.Document' -} + -> m Poppler.Enums.PrintScaling + {- ^ __Returns:__ a 'GI.Poppler.Enums.PrintScaling' that should be used when document is printed -} +documentGetPrintScaling document = liftIO $ do + document' <- unsafeManagedPtrCastPtr document + result <- poppler_document_get_print_scaling document' + let result' = (toEnum . fromIntegral) result + touchManagedPtr document + return result' + +#if ENABLE_OVERLOADING +data DocumentGetPrintScalingMethodInfo +instance (signature ~ (m Poppler.Enums.PrintScaling), MonadIO m, IsDocument a) => O.MethodInfo DocumentGetPrintScalingMethodInfo a signature where + overloadedMethod _ = documentGetPrintScaling + +#endif + +-- method Document::get_producer +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "document", argType = TInterface (Name {namespace = "Poppler", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_document_get_producer" poppler_document_get_producer :: + Ptr Document -> -- document : TInterface (Name {namespace = "Poppler", name = "Document"}) + IO CString + +{- | +Returns the producer of the document. If the document was converted +from another format, the producer is the name of the product +that converted it to PDF + +/Since: 0.16/ +-} +documentGetProducer :: + (B.CallStack.HasCallStack, MonadIO m, IsDocument a) => + a + {- ^ /@document@/: A 'GI.Poppler.Objects.Document.Document' -} + -> m T.Text + {- ^ __Returns:__ a new allocated string containing the producer + of /@document@/, or 'Nothing' -} +documentGetProducer document = liftIO $ do + document' <- unsafeManagedPtrCastPtr document + result <- poppler_document_get_producer document' + checkUnexpectedReturnNULL "documentGetProducer" result + result' <- cstringToText result + freeMem result + touchManagedPtr document + return result' + +#if ENABLE_OVERLOADING +data DocumentGetProducerMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsDocument a) => O.MethodInfo DocumentGetProducerMethodInfo a signature where + overloadedMethod _ = documentGetProducer + +#endif + +-- method Document::get_subject +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "document", argType = TInterface (Name {namespace = "Poppler", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_document_get_subject" poppler_document_get_subject :: + Ptr Document -> -- document : TInterface (Name {namespace = "Poppler", name = "Document"}) + IO CString + +{- | +Returns the subject of the document + +/Since: 0.16/ +-} +documentGetSubject :: + (B.CallStack.HasCallStack, MonadIO m, IsDocument a) => + a + {- ^ /@document@/: A 'GI.Poppler.Objects.Document.Document' -} + -> m T.Text + {- ^ __Returns:__ a new allocated string containing the subject + of /@document@/, or 'Nothing' -} +documentGetSubject document = liftIO $ do + document' <- unsafeManagedPtrCastPtr document + result <- poppler_document_get_subject document' + checkUnexpectedReturnNULL "documentGetSubject" result + result' <- cstringToText result + freeMem result + touchManagedPtr document + return result' + +#if ENABLE_OVERLOADING +data DocumentGetSubjectMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsDocument a) => O.MethodInfo DocumentGetSubjectMethodInfo a signature where + overloadedMethod _ = documentGetSubject + +#endif + +-- method Document::get_title +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "document", argType = TInterface (Name {namespace = "Poppler", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_document_get_title" poppler_document_get_title :: + Ptr Document -> -- document : TInterface (Name {namespace = "Poppler", name = "Document"}) + IO CString + +{- | +Returns the document\'s title + +/Since: 0.16/ +-} +documentGetTitle :: + (B.CallStack.HasCallStack, MonadIO m, IsDocument a) => + a + {- ^ /@document@/: A 'GI.Poppler.Objects.Document.Document' -} + -> m T.Text + {- ^ __Returns:__ a new allocated string containing the title + of /@document@/, or 'Nothing' -} +documentGetTitle document = liftIO $ do + document' <- unsafeManagedPtrCastPtr document + result <- poppler_document_get_title document' + checkUnexpectedReturnNULL "documentGetTitle" result + result' <- cstringToText result + freeMem result + touchManagedPtr document + return result' + +#if ENABLE_OVERLOADING +data DocumentGetTitleMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsDocument a) => O.MethodInfo DocumentGetTitleMethodInfo a signature where + overloadedMethod _ = documentGetTitle + +#endif + +-- method Document::has_attachments +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "document", argType = TInterface (Name {namespace = "Poppler", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_document_has_attachments" poppler_document_has_attachments :: + Ptr Document -> -- document : TInterface (Name {namespace = "Poppler", name = "Document"}) + IO CInt + +{- | +Returns 'True' of /@document@/ has any attachments. +-} +documentHasAttachments :: + (B.CallStack.HasCallStack, MonadIO m, IsDocument a) => + a + {- ^ /@document@/: A 'GI.Poppler.Objects.Document.Document' -} + -> m Bool + {- ^ __Returns:__ 'True', if /@document@/ has attachments. -} +documentHasAttachments document = liftIO $ do + document' <- unsafeManagedPtrCastPtr document + result <- poppler_document_has_attachments document' + let result' = (/= 0) result + touchManagedPtr document + return result' + +#if ENABLE_OVERLOADING +data DocumentHasAttachmentsMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsDocument a) => O.MethodInfo DocumentHasAttachmentsMethodInfo a signature where + overloadedMethod _ = documentHasAttachments + +#endif + +-- method Document::is_linearized +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "document", argType = TInterface (Name {namespace = "Poppler", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_document_is_linearized" poppler_document_is_linearized :: + Ptr Document -> -- document : TInterface (Name {namespace = "Poppler", name = "Document"}) + IO CInt + +{- | +Returns whether /@document@/ is linearized or not. Linearization of PDF +enables efficient incremental access of the PDF file in a network environment. + +/Since: 0.16/ +-} +documentIsLinearized :: + (B.CallStack.HasCallStack, MonadIO m, IsDocument a) => + a + {- ^ /@document@/: A 'GI.Poppler.Objects.Document.Document' -} + -> m Bool + {- ^ __Returns:__ 'True' if /@document@/ is linearized, 'False' otherwise -} +documentIsLinearized document = liftIO $ do + document' <- unsafeManagedPtrCastPtr document + result <- poppler_document_is_linearized document' + let result' = (/= 0) result + touchManagedPtr document + return result' + +#if ENABLE_OVERLOADING +data DocumentIsLinearizedMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsDocument a) => O.MethodInfo DocumentIsLinearizedMethodInfo a signature where + overloadedMethod _ = documentIsLinearized + +#endif + +-- method Document::save +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "document", argType = TInterface (Name {namespace = "Poppler", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "uri of file to save", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "poppler_document_save" poppler_document_save :: + Ptr Document -> -- document : TInterface (Name {namespace = "Poppler", name = "Document"}) + CString -> -- uri : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Saves /@document@/. Any change made in the document such as +form fields filled, annotations added or modified +will be saved. +If /@error@/ is set, 'False' will be returned. Possible errors +include those in the @/G_FILE_ERROR/@ domain. +-} +documentSave :: + (B.CallStack.HasCallStack, MonadIO m, IsDocument a) => + a + {- ^ /@document@/: a 'GI.Poppler.Objects.Document.Document' -} + -> T.Text + {- ^ /@uri@/: uri of file to save -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +documentSave document uri = liftIO $ do + document' <- unsafeManagedPtrCastPtr document + uri' <- textToCString uri + onException (do + _ <- propagateGError $ poppler_document_save document' uri' + touchManagedPtr document + freeMem uri' + return () + ) (do + freeMem uri' + ) + +#if ENABLE_OVERLOADING +data DocumentSaveMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsDocument a) => O.MethodInfo DocumentSaveMethodInfo a signature where + overloadedMethod _ = documentSave + +#endif + +-- method Document::save_a_copy +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "document", argType = TInterface (Name {namespace = "Poppler", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "uri of file to save", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "poppler_document_save_a_copy" poppler_document_save_a_copy :: + Ptr Document -> -- document : TInterface (Name {namespace = "Poppler", name = "Document"}) + CString -> -- uri : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Saves a copy of the original /@document@/. +Any change made in the document such as +form fields filled by the user will not be saved. +If /@error@/ is set, 'False' will be returned. Possible errors +include those in the @/G_FILE_ERROR/@ domain. +-} +documentSaveACopy :: + (B.CallStack.HasCallStack, MonadIO m, IsDocument a) => + a + {- ^ /@document@/: a 'GI.Poppler.Objects.Document.Document' -} + -> T.Text + {- ^ /@uri@/: uri of file to save -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +documentSaveACopy document uri = liftIO $ do + document' <- unsafeManagedPtrCastPtr document + uri' <- textToCString uri + onException (do + _ <- propagateGError $ poppler_document_save_a_copy document' uri' + touchManagedPtr document + freeMem uri' + return () + ) (do + freeMem uri' + ) + +#if ENABLE_OVERLOADING +data DocumentSaveACopyMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsDocument a) => O.MethodInfo DocumentSaveACopyMethodInfo a signature where + overloadedMethod _ = documentSaveACopy + +#endif + +-- method Document::set_author +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "document", argType = TInterface (Name {namespace = "Poppler", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "author", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A new author", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_document_set_author" poppler_document_set_author :: + Ptr Document -> -- document : TInterface (Name {namespace = "Poppler", name = "Document"}) + CString -> -- author : TBasicType TUTF8 + IO () + +{- | +Sets the document\'s author. If /@author@/ is 'Nothing', Author +entry is removed from the document\'s Info dictionary. + +/Since: 0.46/ +-} +documentSetAuthor :: + (B.CallStack.HasCallStack, MonadIO m, IsDocument a) => + a + {- ^ /@document@/: A 'GI.Poppler.Objects.Document.Document' -} + -> T.Text + {- ^ /@author@/: A new author -} + -> m () +documentSetAuthor document author = liftIO $ do + document' <- unsafeManagedPtrCastPtr document + author' <- textToCString author + poppler_document_set_author document' author' + touchManagedPtr document + freeMem author' + return () + +#if ENABLE_OVERLOADING +data DocumentSetAuthorMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsDocument a) => O.MethodInfo DocumentSetAuthorMethodInfo a signature where + overloadedMethod _ = documentSetAuthor + +#endif + +-- method Document::set_creation_date +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "document", argType = TInterface (Name {namespace = "Poppler", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "creation_date", argType = TBasicType TLong, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A new creation date", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_document_set_creation_date" poppler_document_set_creation_date :: + Ptr Document -> -- document : TInterface (Name {namespace = "Poppler", name = "Document"}) + CLong -> -- creation_date : TBasicType TLong + IO () + +{- | +Sets the document\'s creation date. If /@creationDate@/ is -1, CreationDate +entry is removed from the document\'s Info dictionary. + +/Since: 0.46/ +-} +documentSetCreationDate :: + (B.CallStack.HasCallStack, MonadIO m, IsDocument a) => + a + {- ^ /@document@/: A 'GI.Poppler.Objects.Document.Document' -} + -> CLong + {- ^ /@creationDate@/: A new creation date -} + -> m () +documentSetCreationDate document creationDate = liftIO $ do + document' <- unsafeManagedPtrCastPtr document + poppler_document_set_creation_date document' creationDate + touchManagedPtr document + return () + +#if ENABLE_OVERLOADING +data DocumentSetCreationDateMethodInfo +instance (signature ~ (CLong -> m ()), MonadIO m, IsDocument a) => O.MethodInfo DocumentSetCreationDateMethodInfo a signature where + overloadedMethod _ = documentSetCreationDate + +#endif + +-- method Document::set_creator +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "document", argType = TInterface (Name {namespace = "Poppler", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "creator", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A new creator", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_document_set_creator" poppler_document_set_creator :: + Ptr Document -> -- document : TInterface (Name {namespace = "Poppler", name = "Document"}) + CString -> -- creator : TBasicType TUTF8 + IO () + +{- | +Sets the document\'s creator. If /@creator@/ is 'Nothing', Creator +entry is removed from the document\'s Info dictionary. + +/Since: 0.46/ +-} +documentSetCreator :: + (B.CallStack.HasCallStack, MonadIO m, IsDocument a) => + a + {- ^ /@document@/: A 'GI.Poppler.Objects.Document.Document' -} + -> T.Text + {- ^ /@creator@/: A new creator -} + -> m () +documentSetCreator document creator = liftIO $ do + document' <- unsafeManagedPtrCastPtr document + creator' <- textToCString creator + poppler_document_set_creator document' creator' + touchManagedPtr document + freeMem creator' + return () + +#if ENABLE_OVERLOADING +data DocumentSetCreatorMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsDocument a) => O.MethodInfo DocumentSetCreatorMethodInfo a signature where + overloadedMethod _ = documentSetCreator + +#endif + +-- method Document::set_keywords +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "document", argType = TInterface (Name {namespace = "Poppler", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "keywords", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "New keywords", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_document_set_keywords" poppler_document_set_keywords :: + Ptr Document -> -- document : TInterface (Name {namespace = "Poppler", name = "Document"}) + CString -> -- keywords : TBasicType TUTF8 + IO () + +{- | +Sets the document\'s keywords. If /@keywords@/ is 'Nothing', +Keywords entry is removed from the document\'s Info dictionary. + +/Since: 0.46/ +-} +documentSetKeywords :: + (B.CallStack.HasCallStack, MonadIO m, IsDocument a) => + a + {- ^ /@document@/: A 'GI.Poppler.Objects.Document.Document' -} + -> T.Text + {- ^ /@keywords@/: New keywords -} + -> m () +documentSetKeywords document keywords = liftIO $ do + document' <- unsafeManagedPtrCastPtr document + keywords' <- textToCString keywords + poppler_document_set_keywords document' keywords' + touchManagedPtr document + freeMem keywords' + return () + +#if ENABLE_OVERLOADING +data DocumentSetKeywordsMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsDocument a) => O.MethodInfo DocumentSetKeywordsMethodInfo a signature where + overloadedMethod _ = documentSetKeywords + +#endif + +-- method Document::set_modification_date +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "document", argType = TInterface (Name {namespace = "Poppler", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "modification_date", argType = TBasicType TLong, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A new modification date", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_document_set_modification_date" poppler_document_set_modification_date :: + Ptr Document -> -- document : TInterface (Name {namespace = "Poppler", name = "Document"}) + CLong -> -- modification_date : TBasicType TLong + IO () + +{- | +Sets the document\'s modification date. If /@modificationDate@/ is -1, ModDate +entry is removed from the document\'s Info dictionary. + +/Since: 0.46/ +-} +documentSetModificationDate :: + (B.CallStack.HasCallStack, MonadIO m, IsDocument a) => + a + {- ^ /@document@/: A 'GI.Poppler.Objects.Document.Document' -} + -> CLong + {- ^ /@modificationDate@/: A new modification date -} + -> m () +documentSetModificationDate document modificationDate = liftIO $ do + document' <- unsafeManagedPtrCastPtr document + poppler_document_set_modification_date document' modificationDate + touchManagedPtr document + return () + +#if ENABLE_OVERLOADING +data DocumentSetModificationDateMethodInfo +instance (signature ~ (CLong -> m ()), MonadIO m, IsDocument a) => O.MethodInfo DocumentSetModificationDateMethodInfo a signature where + overloadedMethod _ = documentSetModificationDate + +#endif + +-- method Document::set_producer +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "document", argType = TInterface (Name {namespace = "Poppler", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "producer", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A new producer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_document_set_producer" poppler_document_set_producer :: + Ptr Document -> -- document : TInterface (Name {namespace = "Poppler", name = "Document"}) + CString -> -- producer : TBasicType TUTF8 + IO () + +{- | +Sets the document\'s producer. If /@producer@/ is 'Nothing', +Producer entry is removed from the document\'s Info dictionary. + +/Since: 0.46/ +-} +documentSetProducer :: + (B.CallStack.HasCallStack, MonadIO m, IsDocument a) => + a + {- ^ /@document@/: A 'GI.Poppler.Objects.Document.Document' -} + -> T.Text + {- ^ /@producer@/: A new producer -} + -> m () +documentSetProducer document producer = liftIO $ do + document' <- unsafeManagedPtrCastPtr document + producer' <- textToCString producer + poppler_document_set_producer document' producer' + touchManagedPtr document + freeMem producer' + return () + +#if ENABLE_OVERLOADING +data DocumentSetProducerMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsDocument a) => O.MethodInfo DocumentSetProducerMethodInfo a signature where + overloadedMethod _ = documentSetProducer + +#endif + +-- method Document::set_subject +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "document", argType = TInterface (Name {namespace = "Poppler", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "subject", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A new subject", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_document_set_subject" poppler_document_set_subject :: + Ptr Document -> -- document : TInterface (Name {namespace = "Poppler", name = "Document"}) + CString -> -- subject : TBasicType TUTF8 + IO () + +{- | +Sets the document\'s subject. If /@subject@/ is 'Nothing', Subject +entry is removed from the document\'s Info dictionary. + +/Since: 0.46/ +-} +documentSetSubject :: + (B.CallStack.HasCallStack, MonadIO m, IsDocument a) => + a + {- ^ /@document@/: A 'GI.Poppler.Objects.Document.Document' -} + -> T.Text + {- ^ /@subject@/: A new subject -} + -> m () +documentSetSubject document subject = liftIO $ do + document' <- unsafeManagedPtrCastPtr document + subject' <- textToCString subject + poppler_document_set_subject document' subject' + touchManagedPtr document + freeMem subject' + return () + +#if ENABLE_OVERLOADING +data DocumentSetSubjectMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsDocument a) => O.MethodInfo DocumentSetSubjectMethodInfo a signature where + overloadedMethod _ = documentSetSubject + +#endif + +-- method Document::set_title +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "document", argType = TInterface (Name {namespace = "Poppler", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "title", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A new title", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_document_set_title" poppler_document_set_title :: + Ptr Document -> -- document : TInterface (Name {namespace = "Poppler", name = "Document"}) + CString -> -- title : TBasicType TUTF8 + IO () + +{- | +Sets the document\'s title. If /@title@/ is 'Nothing', Title entry +is removed from the document\'s Info dictionary. + +/Since: 0.46/ +-} +documentSetTitle :: + (B.CallStack.HasCallStack, MonadIO m, IsDocument a) => + a + {- ^ /@document@/: A 'GI.Poppler.Objects.Document.Document' -} + -> T.Text + {- ^ /@title@/: A new title -} + -> m () +documentSetTitle document title = liftIO $ do + document' <- unsafeManagedPtrCastPtr document + title' <- textToCString title + poppler_document_set_title document' title' + touchManagedPtr document + freeMem title' + return () + +#if ENABLE_OVERLOADING +data DocumentSetTitleMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsDocument a) => O.MethodInfo DocumentSetTitleMethodInfo a signature where + overloadedMethod _ = documentSetTitle + +#endif + + 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,212 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Poppler.Objects.Document where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype Document = Document (ManagedPtr Document) +instance GObject Document where +class (GObject o, O.IsDescendantOf Document o) => IsDocument o +instance (GObject o, O.IsDescendantOf Document o) => IsDocument o +instance O.HasParentTypes Document +#if ENABLE_OVERLOADING +data DocumentAuthorPropertyInfo +#endif +#if ENABLE_OVERLOADING +data DocumentCreationDatePropertyInfo +#endif +#if ENABLE_OVERLOADING +data DocumentCreatorPropertyInfo +#endif +#if ENABLE_OVERLOADING +data DocumentFormatPropertyInfo +#endif +#if ENABLE_OVERLOADING +data DocumentFormatMajorPropertyInfo +#endif +#if ENABLE_OVERLOADING +data DocumentFormatMinorPropertyInfo +#endif +#if ENABLE_OVERLOADING +data DocumentKeywordsPropertyInfo +#endif +#if ENABLE_OVERLOADING +data DocumentLinearizedPropertyInfo +#endif +#if ENABLE_OVERLOADING +data DocumentMetadataPropertyInfo +#endif +#if ENABLE_OVERLOADING +data DocumentModDatePropertyInfo +#endif +#if ENABLE_OVERLOADING +data DocumentPageLayoutPropertyInfo +#endif +#if ENABLE_OVERLOADING +data DocumentPageModePropertyInfo +#endif +#if ENABLE_OVERLOADING +data DocumentPermissionsPropertyInfo +#endif +#if ENABLE_OVERLOADING +data DocumentPrintScalingPropertyInfo +#endif +#if ENABLE_OVERLOADING +data DocumentProducerPropertyInfo +#endif +#if ENABLE_OVERLOADING +data DocumentSubjectPropertyInfo +#endif +#if ENABLE_OVERLOADING +data DocumentSubtypePropertyInfo +#endif +#if ENABLE_OVERLOADING +data DocumentSubtypeConformancePropertyInfo +#endif +#if ENABLE_OVERLOADING +data DocumentSubtypePartPropertyInfo +#endif +#if ENABLE_OVERLOADING +data DocumentSubtypeStringPropertyInfo +#endif +#if ENABLE_OVERLOADING +data DocumentTitlePropertyInfo +#endif +#if ENABLE_OVERLOADING +data DocumentViewerPreferencesPropertyInfo +#endif +#if ENABLE_OVERLOADING +data DocumentFindDestMethodInfo +#endif +#if ENABLE_OVERLOADING +data DocumentGetAttachmentsMethodInfo +#endif +#if ENABLE_OVERLOADING +data DocumentGetAuthorMethodInfo +#endif +#if ENABLE_OVERLOADING +data DocumentGetCreationDateMethodInfo +#endif +#if ENABLE_OVERLOADING +data DocumentGetCreatorMethodInfo +#endif +#if ENABLE_OVERLOADING +data DocumentGetFormFieldMethodInfo +#endif +#if ENABLE_OVERLOADING +data DocumentGetIdMethodInfo +#endif +#if ENABLE_OVERLOADING +data DocumentGetKeywordsMethodInfo +#endif +#if ENABLE_OVERLOADING +data DocumentGetMetadataMethodInfo +#endif +#if ENABLE_OVERLOADING +data DocumentGetModificationDateMethodInfo +#endif +#if ENABLE_OVERLOADING +data DocumentGetNAttachmentsMethodInfo +#endif +#if ENABLE_OVERLOADING +data DocumentGetNPagesMethodInfo +#endif +#if ENABLE_OVERLOADING +data DocumentGetPageMethodInfo +#endif +#if ENABLE_OVERLOADING +data DocumentGetPageByLabelMethodInfo +#endif +#if ENABLE_OVERLOADING +data DocumentGetPageLayoutMethodInfo +#endif +#if ENABLE_OVERLOADING +data DocumentGetPageModeMethodInfo +#endif +#if ENABLE_OVERLOADING +data DocumentGetPdfConformanceMethodInfo +#endif +#if ENABLE_OVERLOADING +data DocumentGetPdfPartMethodInfo +#endif +#if ENABLE_OVERLOADING +data DocumentGetPdfSubtypeMethodInfo +#endif +#if ENABLE_OVERLOADING +data DocumentGetPdfSubtypeStringMethodInfo +#endif +#if ENABLE_OVERLOADING +data DocumentGetPdfVersionMethodInfo +#endif +#if ENABLE_OVERLOADING +data DocumentGetPdfVersionStringMethodInfo +#endif +#if ENABLE_OVERLOADING +data DocumentGetPermissionsMethodInfo +#endif +#if ENABLE_OVERLOADING +data DocumentGetPrintScalingMethodInfo +#endif +#if ENABLE_OVERLOADING +data DocumentGetProducerMethodInfo +#endif +#if ENABLE_OVERLOADING +data DocumentGetSubjectMethodInfo +#endif +#if ENABLE_OVERLOADING +data DocumentGetTitleMethodInfo +#endif +#if ENABLE_OVERLOADING +data DocumentHasAttachmentsMethodInfo +#endif +#if ENABLE_OVERLOADING +data DocumentIsLinearizedMethodInfo +#endif +#if ENABLE_OVERLOADING +data DocumentSaveMethodInfo +#endif +#if ENABLE_OVERLOADING +data DocumentSaveACopyMethodInfo +#endif +#if ENABLE_OVERLOADING +data DocumentSetAuthorMethodInfo +#endif +#if ENABLE_OVERLOADING +data DocumentSetCreationDateMethodInfo +#endif +#if ENABLE_OVERLOADING +data DocumentSetCreatorMethodInfo +#endif +#if ENABLE_OVERLOADING +data DocumentSetKeywordsMethodInfo +#endif +#if ENABLE_OVERLOADING +data DocumentSetModificationDateMethodInfo +#endif +#if ENABLE_OVERLOADING +data DocumentSetProducerMethodInfo +#endif +#if ENABLE_OVERLOADING +data DocumentSetSubjectMethodInfo +#endif +#if ENABLE_OVERLOADING +data DocumentSetTitleMethodInfo +#endif 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,273 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Poppler.Objects.FontInfo + ( + +-- * Exported types + FontInfo(..) , + IsFontInfo , + toFontInfo , + noFontInfo , + + + -- * Methods +-- ** free #method:free# + +#if ENABLE_OVERLOADING + FontInfoFreeMethodInfo , +#endif + fontInfoFree , + + +-- ** new #method:new# + + fontInfoNew , + + +-- ** scan #method:scan# + +#if ENABLE_OVERLOADING + FontInfoScanMethodInfo , +#endif + fontInfoScan , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import qualified GI.GObject.Objects.Object as GObject.Object +import {-# SOURCE #-} qualified GI.Poppler.Objects.Document as Poppler.Document +import {-# SOURCE #-} qualified GI.Poppler.Structs.FontsIter as Poppler.FontsIter + +-- | Memory-managed wrapper type. +newtype FontInfo = FontInfo (ManagedPtr FontInfo) +foreign import ccall "poppler_font_info_get_type" + c_poppler_font_info_get_type :: IO GType + +instance GObject FontInfo where + gobjectType = c_poppler_font_info_get_type + + +-- | Type class for types which can be safely cast to `FontInfo`, for instance with `toFontInfo`. +class (GObject o, O.IsDescendantOf FontInfo o) => IsFontInfo o +instance (GObject o, O.IsDescendantOf FontInfo o) => IsFontInfo o + +instance O.HasParentTypes FontInfo +type instance O.ParentTypes FontInfo = '[GObject.Object.Object] + +-- | Cast to `FontInfo`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toFontInfo :: (MonadIO m, IsFontInfo o) => o -> m FontInfo +toFontInfo = liftIO . unsafeCastTo FontInfo + +-- | A convenience alias for `Nothing` :: `Maybe` `FontInfo`. +noFontInfo :: Maybe FontInfo +noFontInfo = Nothing + +#if ENABLE_OVERLOADING +type family ResolveFontInfoMethod (t :: Symbol) (o :: *) :: * where + ResolveFontInfoMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveFontInfoMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveFontInfoMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveFontInfoMethod "free" o = FontInfoFreeMethodInfo + ResolveFontInfoMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveFontInfoMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveFontInfoMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveFontInfoMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveFontInfoMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveFontInfoMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveFontInfoMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveFontInfoMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveFontInfoMethod "scan" o = FontInfoScanMethodInfo + ResolveFontInfoMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveFontInfoMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveFontInfoMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveFontInfoMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveFontInfoMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveFontInfoMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveFontInfoMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveFontInfoMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveFontInfoMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveFontInfoMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveFontInfoMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveFontInfoMethod t FontInfo, O.MethodInfo info FontInfo p) => OL.IsLabel t (FontInfo -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList FontInfo +type instance O.AttributeList FontInfo = FontInfoAttributeList +type FontInfoAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList FontInfo = FontInfoSignalList +type FontInfoSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method FontInfo::new +-- method type : Constructor +-- Args : [Arg {argCName = "document", argType = TInterface (Name {namespace = "Poppler", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "FontInfo"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_font_info_new" poppler_font_info_new :: + Ptr Poppler.Document.Document -> -- document : TInterface (Name {namespace = "Poppler", name = "Document"}) + IO (Ptr FontInfo) + +{- | +Creates a new 'GI.Poppler.Objects.FontInfo.FontInfo' object +-} +fontInfoNew :: + (B.CallStack.HasCallStack, MonadIO m, Poppler.Document.IsDocument a) => + a + {- ^ /@document@/: a 'GI.Poppler.Objects.Document.Document' -} + -> m FontInfo + {- ^ __Returns:__ a new 'GI.Poppler.Objects.FontInfo.FontInfo' instance -} +fontInfoNew document = liftIO $ do + document' <- unsafeManagedPtrCastPtr document + result <- poppler_font_info_new document' + checkUnexpectedReturnNULL "fontInfoNew" result + result' <- (wrapObject FontInfo) result + touchManagedPtr document + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method FontInfo::free +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "font_info", argType = TInterface (Name {namespace = "Poppler", name = "FontInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_font_info_free" poppler_font_info_free :: + Ptr FontInfo -> -- font_info : TInterface (Name {namespace = "Poppler", name = "FontInfo"}) + IO () + +{- | +/No description available in the introspection data./ +-} +fontInfoFree :: + (B.CallStack.HasCallStack, MonadIO m, IsFontInfo a) => + a + -> m () +fontInfoFree fontInfo = liftIO $ do + fontInfo' <- unsafeManagedPtrCastPtr fontInfo + poppler_font_info_free fontInfo' + touchManagedPtr fontInfo + return () + +#if ENABLE_OVERLOADING +data FontInfoFreeMethodInfo +instance (signature ~ (m ()), MonadIO m, IsFontInfo a) => O.MethodInfo FontInfoFreeMethodInfo a signature where + overloadedMethod _ = fontInfoFree + +#endif + +-- method FontInfo::scan +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "font_info", argType = TInterface (Name {namespace = "Poppler", name = "FontInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerFontInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_pages", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "number of pages to scan", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "iter", argType = TInterface (Name {namespace = "Poppler", name = "FontsIter"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for a #PopplerFontsIter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_font_info_scan" poppler_font_info_scan :: + Ptr FontInfo -> -- font_info : TInterface (Name {namespace = "Poppler", name = "FontInfo"}) + Int32 -> -- n_pages : TBasicType TInt + Ptr (Ptr Poppler.FontsIter.FontsIter) -> -- iter : TInterface (Name {namespace = "Poppler", name = "FontsIter"}) + IO CInt + +{- | +Scans the document associated with /@fontInfo@/ for fonts. At most +/@nPages@/ will be scanned starting from the current iterator. /@iter@/ will +point to the first font scanned. + +Here is a simple example of code to scan fonts in a document + +\\ +font_info = poppler_font_info_new (document); +while (poppler_font_info_scan (font_info, 20, &fonts_iter)) { + if (!fonts_iter) + continue; \/\* No fonts found in these 20 pages *\\/ + do { + \/\* Do something with font iter *\\/ + g_print (\"Font Name: @/s/@\\n\", poppler_fonts_iter_get_name (fonts_iter)); + } while (poppler_fonts_iter_next (fonts_iter)); + poppler_fonts_iter_free (fonts_iter); +} +\<\/programlisting>\<\/informalexample> +-} +fontInfoScan :: + (B.CallStack.HasCallStack, MonadIO m, IsFontInfo a) => + a + {- ^ /@fontInfo@/: a 'GI.Poppler.Objects.FontInfo.FontInfo' -} + -> Int32 + {- ^ /@nPages@/: number of pages to scan -} + -> m ((Bool, Poppler.FontsIter.FontsIter)) + {- ^ __Returns:__ 'True', if there are more fonts left to scan -} +fontInfoScan fontInfo nPages = liftIO $ do + fontInfo' <- unsafeManagedPtrCastPtr fontInfo + iter <- allocMem :: IO (Ptr (Ptr Poppler.FontsIter.FontsIter)) + result <- poppler_font_info_scan fontInfo' nPages iter + let result' = (/= 0) result + iter' <- peek iter + iter'' <- (wrapBoxed Poppler.FontsIter.FontsIter) iter' + touchManagedPtr fontInfo + freeMem iter + return (result', iter'') + +#if ENABLE_OVERLOADING +data FontInfoScanMethodInfo +instance (signature ~ (Int32 -> m ((Bool, Poppler.FontsIter.FontsIter))), MonadIO m, IsFontInfo a) => O.MethodInfo FontInfoScanMethodInfo a signature where + overloadedMethod _ = fontInfoScan + +#endif + + 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,35 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Poppler.Objects.FontInfo where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype FontInfo = FontInfo (ManagedPtr FontInfo) +instance GObject FontInfo where +class (GObject o, O.IsDescendantOf FontInfo o) => IsFontInfo o +instance (GObject o, O.IsDescendantOf FontInfo o) => IsFontInfo o +instance O.HasParentTypes FontInfo +#if ENABLE_OVERLOADING +data FontInfoFreeMethodInfo +#endif +#if ENABLE_OVERLOADING +data FontInfoScanMethodInfo +#endif 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,1624 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Poppler.Objects.FormField + ( + +-- * Exported types + FormField(..) , + IsFormField , + toFormField , + noFormField , + + + -- * Methods +-- ** buttonGetButtonType #method:buttonGetButtonType# + +#if ENABLE_OVERLOADING + FormFieldButtonGetButtonTypeMethodInfo , +#endif + formFieldButtonGetButtonType , + + +-- ** buttonGetState #method:buttonGetState# + +#if ENABLE_OVERLOADING + FormFieldButtonGetStateMethodInfo , +#endif + formFieldButtonGetState , + + +-- ** buttonSetState #method:buttonSetState# + +#if ENABLE_OVERLOADING + FormFieldButtonSetStateMethodInfo , +#endif + formFieldButtonSetState , + + +-- ** choiceCanSelectMultiple #method:choiceCanSelectMultiple# + +#if ENABLE_OVERLOADING + FormFieldChoiceCanSelectMultipleMethodInfo, +#endif + formFieldChoiceCanSelectMultiple , + + +-- ** choiceCommitOnChange #method:choiceCommitOnChange# + +#if ENABLE_OVERLOADING + FormFieldChoiceCommitOnChangeMethodInfo , +#endif + formFieldChoiceCommitOnChange , + + +-- ** choiceDoSpellCheck #method:choiceDoSpellCheck# + +#if ENABLE_OVERLOADING + FormFieldChoiceDoSpellCheckMethodInfo , +#endif + formFieldChoiceDoSpellCheck , + + +-- ** choiceGetChoiceType #method:choiceGetChoiceType# + +#if ENABLE_OVERLOADING + FormFieldChoiceGetChoiceTypeMethodInfo , +#endif + formFieldChoiceGetChoiceType , + + +-- ** choiceGetItem #method:choiceGetItem# + +#if ENABLE_OVERLOADING + FormFieldChoiceGetItemMethodInfo , +#endif + formFieldChoiceGetItem , + + +-- ** choiceGetNItems #method:choiceGetNItems# + +#if ENABLE_OVERLOADING + FormFieldChoiceGetNItemsMethodInfo , +#endif + formFieldChoiceGetNItems , + + +-- ** choiceGetText #method:choiceGetText# + +#if ENABLE_OVERLOADING + FormFieldChoiceGetTextMethodInfo , +#endif + formFieldChoiceGetText , + + +-- ** choiceIsEditable #method:choiceIsEditable# + +#if ENABLE_OVERLOADING + FormFieldChoiceIsEditableMethodInfo , +#endif + formFieldChoiceIsEditable , + + +-- ** choiceIsItemSelected #method:choiceIsItemSelected# + +#if ENABLE_OVERLOADING + FormFieldChoiceIsItemSelectedMethodInfo , +#endif + formFieldChoiceIsItemSelected , + + +-- ** choiceSelectItem #method:choiceSelectItem# + +#if ENABLE_OVERLOADING + FormFieldChoiceSelectItemMethodInfo , +#endif + formFieldChoiceSelectItem , + + +-- ** choiceSetText #method:choiceSetText# + +#if ENABLE_OVERLOADING + FormFieldChoiceSetTextMethodInfo , +#endif + formFieldChoiceSetText , + + +-- ** choiceToggleItem #method:choiceToggleItem# + +#if ENABLE_OVERLOADING + FormFieldChoiceToggleItemMethodInfo , +#endif + formFieldChoiceToggleItem , + + +-- ** choiceUnselectAll #method:choiceUnselectAll# + +#if ENABLE_OVERLOADING + FormFieldChoiceUnselectAllMethodInfo , +#endif + formFieldChoiceUnselectAll , + + +-- ** getAction #method:getAction# + +#if ENABLE_OVERLOADING + FormFieldGetActionMethodInfo , +#endif + formFieldGetAction , + + +-- ** getAdditionalAction #method:getAdditionalAction# + +#if ENABLE_OVERLOADING + FormFieldGetAdditionalActionMethodInfo , +#endif + formFieldGetAdditionalAction , + + +-- ** getFieldType #method:getFieldType# + +#if ENABLE_OVERLOADING + FormFieldGetFieldTypeMethodInfo , +#endif + formFieldGetFieldType , + + +-- ** getFontSize #method:getFontSize# + +#if ENABLE_OVERLOADING + FormFieldGetFontSizeMethodInfo , +#endif + formFieldGetFontSize , + + +-- ** getId #method:getId# + +#if ENABLE_OVERLOADING + FormFieldGetIdMethodInfo , +#endif + formFieldGetId , + + +-- ** getMappingName #method:getMappingName# + +#if ENABLE_OVERLOADING + FormFieldGetMappingNameMethodInfo , +#endif + formFieldGetMappingName , + + +-- ** getName #method:getName# + +#if ENABLE_OVERLOADING + FormFieldGetNameMethodInfo , +#endif + formFieldGetName , + + +-- ** getPartialName #method:getPartialName# + +#if ENABLE_OVERLOADING + FormFieldGetPartialNameMethodInfo , +#endif + formFieldGetPartialName , + + +-- ** isReadOnly #method:isReadOnly# + +#if ENABLE_OVERLOADING + FormFieldIsReadOnlyMethodInfo , +#endif + formFieldIsReadOnly , + + +-- ** textDoScroll #method:textDoScroll# + +#if ENABLE_OVERLOADING + FormFieldTextDoScrollMethodInfo , +#endif + formFieldTextDoScroll , + + +-- ** textDoSpellCheck #method:textDoSpellCheck# + +#if ENABLE_OVERLOADING + FormFieldTextDoSpellCheckMethodInfo , +#endif + formFieldTextDoSpellCheck , + + +-- ** textGetMaxLen #method:textGetMaxLen# + +#if ENABLE_OVERLOADING + FormFieldTextGetMaxLenMethodInfo , +#endif + formFieldTextGetMaxLen , + + +-- ** textGetText #method:textGetText# + +#if ENABLE_OVERLOADING + FormFieldTextGetTextMethodInfo , +#endif + formFieldTextGetText , + + +-- ** textGetTextType #method:textGetTextType# + +#if ENABLE_OVERLOADING + FormFieldTextGetTextTypeMethodInfo , +#endif + formFieldTextGetTextType , + + +-- ** textIsPassword #method:textIsPassword# + +#if ENABLE_OVERLOADING + FormFieldTextIsPasswordMethodInfo , +#endif + formFieldTextIsPassword , + + +-- ** textIsRichText #method:textIsRichText# + +#if ENABLE_OVERLOADING + FormFieldTextIsRichTextMethodInfo , +#endif + formFieldTextIsRichText , + + +-- ** textSetText #method:textSetText# + +#if ENABLE_OVERLOADING + FormFieldTextSetTextMethodInfo , +#endif + formFieldTextSetText , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import qualified GI.GObject.Objects.Object as GObject.Object +import {-# SOURCE #-} qualified GI.Poppler.Enums as Poppler.Enums +import {-# SOURCE #-} qualified GI.Poppler.Unions.Action as Poppler.Action + +-- | Memory-managed wrapper type. +newtype FormField = FormField (ManagedPtr FormField) +foreign import ccall "poppler_form_field_get_type" + c_poppler_form_field_get_type :: IO GType + +instance GObject FormField where + gobjectType = c_poppler_form_field_get_type + + +-- | Type class for types which can be safely cast to `FormField`, for instance with `toFormField`. +class (GObject o, O.IsDescendantOf FormField o) => IsFormField o +instance (GObject o, O.IsDescendantOf FormField o) => IsFormField o + +instance O.HasParentTypes FormField +type instance O.ParentTypes FormField = '[GObject.Object.Object] + +-- | Cast to `FormField`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toFormField :: (MonadIO m, IsFormField o) => o -> m FormField +toFormField = liftIO . unsafeCastTo FormField + +-- | A convenience alias for `Nothing` :: `Maybe` `FormField`. +noFormField :: Maybe FormField +noFormField = Nothing + +#if ENABLE_OVERLOADING +type family ResolveFormFieldMethod (t :: Symbol) (o :: *) :: * where + ResolveFormFieldMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveFormFieldMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveFormFieldMethod "buttonGetButtonType" o = FormFieldButtonGetButtonTypeMethodInfo + ResolveFormFieldMethod "buttonGetState" o = FormFieldButtonGetStateMethodInfo + ResolveFormFieldMethod "buttonSetState" o = FormFieldButtonSetStateMethodInfo + ResolveFormFieldMethod "choiceCanSelectMultiple" o = FormFieldChoiceCanSelectMultipleMethodInfo + ResolveFormFieldMethod "choiceCommitOnChange" o = FormFieldChoiceCommitOnChangeMethodInfo + ResolveFormFieldMethod "choiceDoSpellCheck" o = FormFieldChoiceDoSpellCheckMethodInfo + ResolveFormFieldMethod "choiceGetChoiceType" o = FormFieldChoiceGetChoiceTypeMethodInfo + ResolveFormFieldMethod "choiceGetItem" o = FormFieldChoiceGetItemMethodInfo + ResolveFormFieldMethod "choiceGetNItems" o = FormFieldChoiceGetNItemsMethodInfo + ResolveFormFieldMethod "choiceGetText" o = FormFieldChoiceGetTextMethodInfo + ResolveFormFieldMethod "choiceIsEditable" o = FormFieldChoiceIsEditableMethodInfo + ResolveFormFieldMethod "choiceIsItemSelected" o = FormFieldChoiceIsItemSelectedMethodInfo + ResolveFormFieldMethod "choiceSelectItem" o = FormFieldChoiceSelectItemMethodInfo + ResolveFormFieldMethod "choiceSetText" o = FormFieldChoiceSetTextMethodInfo + ResolveFormFieldMethod "choiceToggleItem" o = FormFieldChoiceToggleItemMethodInfo + ResolveFormFieldMethod "choiceUnselectAll" o = FormFieldChoiceUnselectAllMethodInfo + ResolveFormFieldMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveFormFieldMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveFormFieldMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveFormFieldMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveFormFieldMethod "isReadOnly" o = FormFieldIsReadOnlyMethodInfo + ResolveFormFieldMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveFormFieldMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveFormFieldMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveFormFieldMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveFormFieldMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveFormFieldMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveFormFieldMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveFormFieldMethod "textDoScroll" o = FormFieldTextDoScrollMethodInfo + ResolveFormFieldMethod "textDoSpellCheck" o = FormFieldTextDoSpellCheckMethodInfo + ResolveFormFieldMethod "textGetMaxLen" o = FormFieldTextGetMaxLenMethodInfo + ResolveFormFieldMethod "textGetText" o = FormFieldTextGetTextMethodInfo + ResolveFormFieldMethod "textGetTextType" o = FormFieldTextGetTextTypeMethodInfo + ResolveFormFieldMethod "textIsPassword" o = FormFieldTextIsPasswordMethodInfo + ResolveFormFieldMethod "textIsRichText" o = FormFieldTextIsRichTextMethodInfo + ResolveFormFieldMethod "textSetText" o = FormFieldTextSetTextMethodInfo + ResolveFormFieldMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveFormFieldMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveFormFieldMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveFormFieldMethod "getAction" o = FormFieldGetActionMethodInfo + ResolveFormFieldMethod "getAdditionalAction" o = FormFieldGetAdditionalActionMethodInfo + ResolveFormFieldMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveFormFieldMethod "getFieldType" o = FormFieldGetFieldTypeMethodInfo + ResolveFormFieldMethod "getFontSize" o = FormFieldGetFontSizeMethodInfo + ResolveFormFieldMethod "getId" o = FormFieldGetIdMethodInfo + ResolveFormFieldMethod "getMappingName" o = FormFieldGetMappingNameMethodInfo + ResolveFormFieldMethod "getName" o = FormFieldGetNameMethodInfo + ResolveFormFieldMethod "getPartialName" o = FormFieldGetPartialNameMethodInfo + ResolveFormFieldMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveFormFieldMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveFormFieldMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveFormFieldMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveFormFieldMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveFormFieldMethod t FormField, O.MethodInfo info FormField p) => OL.IsLabel t (FormField -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList FormField +type instance O.AttributeList FormField = FormFieldAttributeList +type FormFieldAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList FormField = FormFieldSignalList +type FormFieldSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method FormField::button_get_button_type +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "field", argType = TInterface (Name {namespace = "Poppler", name = "FormField"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerFormField", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "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 -> -- field : TInterface (Name {namespace = "Poppler", name = "FormField"}) + IO CUInt + +{- | +Gets the button type of /@field@/ +-} +formFieldButtonGetButtonType :: + (B.CallStack.HasCallStack, MonadIO m, IsFormField a) => + a + {- ^ /@field@/: a 'GI.Poppler.Objects.FormField.FormField' -} + -> m Poppler.Enums.FormButtonType + {- ^ __Returns:__ 'GI.Poppler.Enums.FormButtonType' of /@field@/ -} +formFieldButtonGetButtonType field = liftIO $ do + field' <- unsafeManagedPtrCastPtr field + result <- poppler_form_field_button_get_button_type field' + let result' = (toEnum . fromIntegral) result + touchManagedPtr field + return result' + +#if ENABLE_OVERLOADING +data FormFieldButtonGetButtonTypeMethodInfo +instance (signature ~ (m Poppler.Enums.FormButtonType), MonadIO m, IsFormField a) => O.MethodInfo FormFieldButtonGetButtonTypeMethodInfo a signature where + overloadedMethod _ = formFieldButtonGetButtonType + +#endif + +-- method FormField::button_get_state +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "field", argType = TInterface (Name {namespace = "Poppler", name = "FormField"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerFormField", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_form_field_button_get_state" poppler_form_field_button_get_state :: + Ptr FormField -> -- field : TInterface (Name {namespace = "Poppler", name = "FormField"}) + IO CInt + +{- | +Queries a 'GI.Poppler.Objects.FormField.FormField' and returns its current state. Returns 'True' if +/@field@/ is pressed in and 'False' if it is raised. +-} +formFieldButtonGetState :: + (B.CallStack.HasCallStack, MonadIO m, IsFormField a) => + a + {- ^ /@field@/: a 'GI.Poppler.Objects.FormField.FormField' -} + -> m Bool + {- ^ __Returns:__ current state of /@field@/ -} +formFieldButtonGetState field = liftIO $ do + field' <- unsafeManagedPtrCastPtr field + result <- poppler_form_field_button_get_state field' + let result' = (/= 0) result + touchManagedPtr field + return result' + +#if ENABLE_OVERLOADING +data FormFieldButtonGetStateMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsFormField a) => O.MethodInfo FormFieldButtonGetStateMethodInfo a signature where + overloadedMethod _ = formFieldButtonGetState + +#endif + +-- method FormField::button_set_state +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "field", argType = TInterface (Name {namespace = "Poppler", name = "FormField"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerFormField", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "state", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE or %FALSE", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_form_field_button_set_state" poppler_form_field_button_set_state :: + Ptr FormField -> -- field : TInterface (Name {namespace = "Poppler", name = "FormField"}) + CInt -> -- state : TBasicType TBoolean + IO () + +{- | +Sets the status of /@field@/. Set to 'True' if you want the 'GI.Poppler.Objects.FormField.FormField' +to be \'pressed in\', and 'False' to raise it. +-} +formFieldButtonSetState :: + (B.CallStack.HasCallStack, MonadIO m, IsFormField a) => + a + {- ^ /@field@/: a 'GI.Poppler.Objects.FormField.FormField' -} + -> Bool + {- ^ /@state@/: 'True' or 'False' -} + -> m () +formFieldButtonSetState field state = liftIO $ do + field' <- unsafeManagedPtrCastPtr field + let state' = (fromIntegral . fromEnum) state + poppler_form_field_button_set_state field' state' + touchManagedPtr field + return () + +#if ENABLE_OVERLOADING +data FormFieldButtonSetStateMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsFormField a) => O.MethodInfo FormFieldButtonSetStateMethodInfo a signature where + overloadedMethod _ = formFieldButtonSetState + +#endif + +-- method FormField::choice_can_select_multiple +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "field", argType = TInterface (Name {namespace = "Poppler", name = "FormField"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerFormField", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_form_field_choice_can_select_multiple" poppler_form_field_choice_can_select_multiple :: + Ptr FormField -> -- field : TInterface (Name {namespace = "Poppler", name = "FormField"}) + IO CInt + +{- | +Checks whether /@field@/ allows multiple choices to be selected +-} +formFieldChoiceCanSelectMultiple :: + (B.CallStack.HasCallStack, MonadIO m, IsFormField a) => + a + {- ^ /@field@/: a 'GI.Poppler.Objects.FormField.FormField' -} + -> m Bool + {- ^ __Returns:__ 'True' if /@field@/ allows multiple choices to be selected -} +formFieldChoiceCanSelectMultiple field = liftIO $ do + field' <- unsafeManagedPtrCastPtr field + result <- poppler_form_field_choice_can_select_multiple field' + let result' = (/= 0) result + touchManagedPtr field + return result' + +#if ENABLE_OVERLOADING +data FormFieldChoiceCanSelectMultipleMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsFormField a) => O.MethodInfo FormFieldChoiceCanSelectMultipleMethodInfo a signature where + overloadedMethod _ = formFieldChoiceCanSelectMultiple + +#endif + +-- method FormField::choice_commit_on_change +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "field", argType = TInterface (Name {namespace = "Poppler", name = "FormField"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_form_field_choice_commit_on_change" poppler_form_field_choice_commit_on_change :: + Ptr FormField -> -- field : TInterface (Name {namespace = "Poppler", name = "FormField"}) + IO CInt + +{- | +/No description available in the introspection data./ +-} +formFieldChoiceCommitOnChange :: + (B.CallStack.HasCallStack, MonadIO m, IsFormField a) => + a + -> m Bool +formFieldChoiceCommitOnChange field = liftIO $ do + field' <- unsafeManagedPtrCastPtr field + result <- poppler_form_field_choice_commit_on_change field' + let result' = (/= 0) result + touchManagedPtr field + return result' + +#if ENABLE_OVERLOADING +data FormFieldChoiceCommitOnChangeMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsFormField a) => O.MethodInfo FormFieldChoiceCommitOnChangeMethodInfo a signature where + overloadedMethod _ = formFieldChoiceCommitOnChange + +#endif + +-- method FormField::choice_do_spell_check +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "field", argType = TInterface (Name {namespace = "Poppler", name = "FormField"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerFormField", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_form_field_choice_do_spell_check" poppler_form_field_choice_do_spell_check :: + Ptr FormField -> -- field : TInterface (Name {namespace = "Poppler", name = "FormField"}) + IO CInt + +{- | +Checks whether spell checking should be done for the contents of /@field@/ +-} +formFieldChoiceDoSpellCheck :: + (B.CallStack.HasCallStack, MonadIO m, IsFormField a) => + a + {- ^ /@field@/: a 'GI.Poppler.Objects.FormField.FormField' -} + -> m Bool + {- ^ __Returns:__ 'True' if spell checking should be done for /@field@/ -} +formFieldChoiceDoSpellCheck field = liftIO $ do + field' <- unsafeManagedPtrCastPtr field + result <- poppler_form_field_choice_do_spell_check field' + let result' = (/= 0) result + touchManagedPtr field + return result' + +#if ENABLE_OVERLOADING +data FormFieldChoiceDoSpellCheckMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsFormField a) => O.MethodInfo FormFieldChoiceDoSpellCheckMethodInfo a signature where + overloadedMethod _ = formFieldChoiceDoSpellCheck + +#endif + +-- method FormField::choice_get_choice_type +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "field", argType = TInterface (Name {namespace = "Poppler", name = "FormField"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerFormField", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "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 -> -- field : TInterface (Name {namespace = "Poppler", name = "FormField"}) + IO CUInt + +{- | +Gets the choice type of /@field@/ +-} +formFieldChoiceGetChoiceType :: + (B.CallStack.HasCallStack, MonadIO m, IsFormField a) => + a + {- ^ /@field@/: a 'GI.Poppler.Objects.FormField.FormField' -} + -> m Poppler.Enums.FormChoiceType + {- ^ __Returns:__ 'GI.Poppler.Enums.FormChoiceType' of /@field@/ -} +formFieldChoiceGetChoiceType field = liftIO $ do + field' <- unsafeManagedPtrCastPtr field + result <- poppler_form_field_choice_get_choice_type field' + let result' = (toEnum . fromIntegral) result + touchManagedPtr field + return result' + +#if ENABLE_OVERLOADING +data FormFieldChoiceGetChoiceTypeMethodInfo +instance (signature ~ (m Poppler.Enums.FormChoiceType), MonadIO m, IsFormField a) => O.MethodInfo FormFieldChoiceGetChoiceTypeMethodInfo a signature where + overloadedMethod _ = formFieldChoiceGetChoiceType + +#endif + +-- method FormField::choice_get_item +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "field", argType = TInterface (Name {namespace = "Poppler", name = "FormField"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerFormField", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the index of the item", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_form_field_choice_get_item" poppler_form_field_choice_get_item :: + Ptr FormField -> -- field : TInterface (Name {namespace = "Poppler", name = "FormField"}) + Int32 -> -- index : TBasicType TInt + IO CString + +{- | +Returns the contents of the item on /@field@/ at the given index +-} +formFieldChoiceGetItem :: + (B.CallStack.HasCallStack, MonadIO m, IsFormField a) => + a + {- ^ /@field@/: a 'GI.Poppler.Objects.FormField.FormField' -} + -> Int32 + {- ^ /@index@/: the index of the item -} + -> m T.Text + {- ^ __Returns:__ a new allocated string. It must be freed with 'GI.GLib.Functions.free' when done. -} +formFieldChoiceGetItem field index = liftIO $ do + field' <- unsafeManagedPtrCastPtr field + result <- poppler_form_field_choice_get_item field' index + checkUnexpectedReturnNULL "formFieldChoiceGetItem" result + result' <- cstringToText result + freeMem result + touchManagedPtr field + return result' + +#if ENABLE_OVERLOADING +data FormFieldChoiceGetItemMethodInfo +instance (signature ~ (Int32 -> m T.Text), MonadIO m, IsFormField a) => O.MethodInfo FormFieldChoiceGetItemMethodInfo a signature where + overloadedMethod _ = formFieldChoiceGetItem + +#endif + +-- method FormField::choice_get_n_items +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "field", argType = TInterface (Name {namespace = "Poppler", name = "FormField"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerFormField", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_form_field_choice_get_n_items" poppler_form_field_choice_get_n_items :: + Ptr FormField -> -- field : TInterface (Name {namespace = "Poppler", name = "FormField"}) + IO Int32 + +{- | +Returns the number of items on /@field@/ +-} +formFieldChoiceGetNItems :: + (B.CallStack.HasCallStack, MonadIO m, IsFormField a) => + a + {- ^ /@field@/: a 'GI.Poppler.Objects.FormField.FormField' -} + -> m Int32 + {- ^ __Returns:__ the number of items on /@field@/ -} +formFieldChoiceGetNItems field = liftIO $ do + field' <- unsafeManagedPtrCastPtr field + result <- poppler_form_field_choice_get_n_items field' + touchManagedPtr field + return result + +#if ENABLE_OVERLOADING +data FormFieldChoiceGetNItemsMethodInfo +instance (signature ~ (m Int32), MonadIO m, IsFormField a) => O.MethodInfo FormFieldChoiceGetNItemsMethodInfo a signature where + overloadedMethod _ = formFieldChoiceGetNItems + +#endif + +-- method FormField::choice_get_text +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "field", argType = TInterface (Name {namespace = "Poppler", name = "FormField"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerFormField", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_form_field_choice_get_text" poppler_form_field_choice_get_text :: + Ptr FormField -> -- field : TInterface (Name {namespace = "Poppler", name = "FormField"}) + IO CString + +{- | +Retrieves the contents of /@field@/. +-} +formFieldChoiceGetText :: + (B.CallStack.HasCallStack, MonadIO m, IsFormField a) => + a + {- ^ /@field@/: a 'GI.Poppler.Objects.FormField.FormField' -} + -> m T.Text + {- ^ __Returns:__ a new allocated string. It must be freed with 'GI.GLib.Functions.free' when done. -} +formFieldChoiceGetText field = liftIO $ do + field' <- unsafeManagedPtrCastPtr field + result <- poppler_form_field_choice_get_text field' + checkUnexpectedReturnNULL "formFieldChoiceGetText" result + result' <- cstringToText result + freeMem result + touchManagedPtr field + return result' + +#if ENABLE_OVERLOADING +data FormFieldChoiceGetTextMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsFormField a) => O.MethodInfo FormFieldChoiceGetTextMethodInfo a signature where + overloadedMethod _ = formFieldChoiceGetText + +#endif + +-- method FormField::choice_is_editable +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "field", argType = TInterface (Name {namespace = "Poppler", name = "FormField"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerFormField", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_form_field_choice_is_editable" poppler_form_field_choice_is_editable :: + Ptr FormField -> -- field : TInterface (Name {namespace = "Poppler", name = "FormField"}) + IO CInt + +{- | +Checks whether /@field@/ is editable +-} +formFieldChoiceIsEditable :: + (B.CallStack.HasCallStack, MonadIO m, IsFormField a) => + a + {- ^ /@field@/: a 'GI.Poppler.Objects.FormField.FormField' -} + -> m Bool + {- ^ __Returns:__ 'True' if /@field@/ is editable -} +formFieldChoiceIsEditable field = liftIO $ do + field' <- unsafeManagedPtrCastPtr field + result <- poppler_form_field_choice_is_editable field' + let result' = (/= 0) result + touchManagedPtr field + return result' + +#if ENABLE_OVERLOADING +data FormFieldChoiceIsEditableMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsFormField a) => O.MethodInfo FormFieldChoiceIsEditableMethodInfo a signature where + overloadedMethod _ = formFieldChoiceIsEditable + +#endif + +-- method FormField::choice_is_item_selected +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "field", argType = TInterface (Name {namespace = "Poppler", name = "FormField"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerFormField", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the index of the item", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_form_field_choice_is_item_selected" poppler_form_field_choice_is_item_selected :: + Ptr FormField -> -- field : TInterface (Name {namespace = "Poppler", name = "FormField"}) + Int32 -> -- index : TBasicType TInt + IO CInt + +{- | +Checks whether the item at the given index on /@field@/ is currently selected +-} +formFieldChoiceIsItemSelected :: + (B.CallStack.HasCallStack, MonadIO m, IsFormField a) => + a + {- ^ /@field@/: a 'GI.Poppler.Objects.FormField.FormField' -} + -> Int32 + {- ^ /@index@/: the index of the item -} + -> m Bool + {- ^ __Returns:__ 'True' if item at /@index@/ is currently selected -} +formFieldChoiceIsItemSelected field index = liftIO $ do + field' <- unsafeManagedPtrCastPtr field + result <- poppler_form_field_choice_is_item_selected field' index + let result' = (/= 0) result + touchManagedPtr field + return result' + +#if ENABLE_OVERLOADING +data FormFieldChoiceIsItemSelectedMethodInfo +instance (signature ~ (Int32 -> m Bool), MonadIO m, IsFormField a) => O.MethodInfo FormFieldChoiceIsItemSelectedMethodInfo a signature where + overloadedMethod _ = formFieldChoiceIsItemSelected + +#endif + +-- method FormField::choice_select_item +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "field", argType = TInterface (Name {namespace = "Poppler", name = "FormField"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerFormField", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the index of the item", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_form_field_choice_select_item" poppler_form_field_choice_select_item :: + Ptr FormField -> -- field : TInterface (Name {namespace = "Poppler", name = "FormField"}) + Int32 -> -- index : TBasicType TInt + IO () + +{- | +Selects the item at the given index on /@field@/ +-} +formFieldChoiceSelectItem :: + (B.CallStack.HasCallStack, MonadIO m, IsFormField a) => + a + {- ^ /@field@/: a 'GI.Poppler.Objects.FormField.FormField' -} + -> Int32 + {- ^ /@index@/: the index of the item -} + -> m () +formFieldChoiceSelectItem field index = liftIO $ do + field' <- unsafeManagedPtrCastPtr field + poppler_form_field_choice_select_item field' index + touchManagedPtr field + return () + +#if ENABLE_OVERLOADING +data FormFieldChoiceSelectItemMethodInfo +instance (signature ~ (Int32 -> m ()), MonadIO m, IsFormField a) => O.MethodInfo FormFieldChoiceSelectItemMethodInfo a signature where + overloadedMethod _ = formFieldChoiceSelectItem + +#endif + +-- method FormField::choice_set_text +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "field", argType = TInterface (Name {namespace = "Poppler", name = "FormField"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerFormField", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new text", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_form_field_choice_set_text" poppler_form_field_choice_set_text :: + Ptr FormField -> -- field : TInterface (Name {namespace = "Poppler", name = "FormField"}) + CString -> -- text : TBasicType TUTF8 + IO () + +{- | +Sets the text in /@field@/ to the given value, replacing the current contents +-} +formFieldChoiceSetText :: + (B.CallStack.HasCallStack, MonadIO m, IsFormField a) => + a + {- ^ /@field@/: a 'GI.Poppler.Objects.FormField.FormField' -} + -> T.Text + {- ^ /@text@/: the new text -} + -> m () +formFieldChoiceSetText field text = liftIO $ do + field' <- unsafeManagedPtrCastPtr field + text' <- textToCString text + poppler_form_field_choice_set_text field' text' + touchManagedPtr field + freeMem text' + return () + +#if ENABLE_OVERLOADING +data FormFieldChoiceSetTextMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsFormField a) => O.MethodInfo FormFieldChoiceSetTextMethodInfo a signature where + overloadedMethod _ = formFieldChoiceSetText + +#endif + +-- method FormField::choice_toggle_item +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "field", argType = TInterface (Name {namespace = "Poppler", name = "FormField"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerFormField", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the index of the item", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_form_field_choice_toggle_item" poppler_form_field_choice_toggle_item :: + Ptr FormField -> -- field : TInterface (Name {namespace = "Poppler", name = "FormField"}) + Int32 -> -- index : TBasicType TInt + IO () + +{- | +Changes the state of the item at the given index +-} +formFieldChoiceToggleItem :: + (B.CallStack.HasCallStack, MonadIO m, IsFormField a) => + a + {- ^ /@field@/: a 'GI.Poppler.Objects.FormField.FormField' -} + -> Int32 + {- ^ /@index@/: the index of the item -} + -> m () +formFieldChoiceToggleItem field index = liftIO $ do + field' <- unsafeManagedPtrCastPtr field + poppler_form_field_choice_toggle_item field' index + touchManagedPtr field + return () + +#if ENABLE_OVERLOADING +data FormFieldChoiceToggleItemMethodInfo +instance (signature ~ (Int32 -> m ()), MonadIO m, IsFormField a) => O.MethodInfo FormFieldChoiceToggleItemMethodInfo a signature where + overloadedMethod _ = formFieldChoiceToggleItem + +#endif + +-- method FormField::choice_unselect_all +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "field", argType = TInterface (Name {namespace = "Poppler", name = "FormField"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerFormField", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_form_field_choice_unselect_all" poppler_form_field_choice_unselect_all :: + Ptr FormField -> -- field : TInterface (Name {namespace = "Poppler", name = "FormField"}) + IO () + +{- | +Unselects all the items on /@field@/ +-} +formFieldChoiceUnselectAll :: + (B.CallStack.HasCallStack, MonadIO m, IsFormField a) => + a + {- ^ /@field@/: a 'GI.Poppler.Objects.FormField.FormField' -} + -> m () +formFieldChoiceUnselectAll field = liftIO $ do + field' <- unsafeManagedPtrCastPtr field + poppler_form_field_choice_unselect_all field' + touchManagedPtr field + return () + +#if ENABLE_OVERLOADING +data FormFieldChoiceUnselectAllMethodInfo +instance (signature ~ (m ()), MonadIO m, IsFormField a) => O.MethodInfo FormFieldChoiceUnselectAllMethodInfo a signature where + overloadedMethod _ = formFieldChoiceUnselectAll + +#endif + +-- method FormField::get_action +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "field", argType = TInterface (Name {namespace = "Poppler", name = "FormField"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerFormField", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "Action"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_form_field_get_action" poppler_form_field_get_action :: + Ptr FormField -> -- field : TInterface (Name {namespace = "Poppler", name = "FormField"}) + IO (Ptr Poppler.Action.Action) + +{- | +Retrieves the action ('GI.Poppler.Unions.Action.Action') that shall be +performed when /@field@/ is activated, or 'Nothing' + +/Since: 0.18/ +-} +formFieldGetAction :: + (B.CallStack.HasCallStack, MonadIO m, IsFormField a) => + a + {- ^ /@field@/: a 'GI.Poppler.Objects.FormField.FormField' -} + -> m Poppler.Action.Action + {- ^ __Returns:__ the action to perform. The returned + object is owned by /@field@/ and should not be freed -} +formFieldGetAction field = liftIO $ do + field' <- unsafeManagedPtrCastPtr field + result <- poppler_form_field_get_action field' + checkUnexpectedReturnNULL "formFieldGetAction" result + result' <- (newBoxed Poppler.Action.Action) result + touchManagedPtr field + return result' + +#if ENABLE_OVERLOADING +data FormFieldGetActionMethodInfo +instance (signature ~ (m Poppler.Action.Action), MonadIO m, IsFormField a) => O.MethodInfo FormFieldGetActionMethodInfo a signature where + overloadedMethod _ = formFieldGetAction + +#endif + +-- method FormField::get_additional_action +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "field", argType = TInterface (Name {namespace = "Poppler", name = "FormField"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerFormField", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TInterface (Name {namespace = "Poppler", name = "AdditionalActionType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the type of additional action", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "Action"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_form_field_get_additional_action" poppler_form_field_get_additional_action :: + Ptr FormField -> -- field : TInterface (Name {namespace = "Poppler", name = "FormField"}) + CUInt -> -- type : TInterface (Name {namespace = "Poppler", name = "AdditionalActionType"}) + IO (Ptr Poppler.Action.Action) + +{- | +Retrieves the action ('GI.Poppler.Unions.Action.Action') that shall be performed when +an additional action is triggered on /@field@/, or 'Nothing'. + +/Since: 0.72/ +-} +formFieldGetAdditionalAction :: + (B.CallStack.HasCallStack, MonadIO m, IsFormField a) => + a + {- ^ /@field@/: a 'GI.Poppler.Objects.FormField.FormField' -} + -> Poppler.Enums.AdditionalActionType + {- ^ /@type@/: the type of additional action -} + -> m Poppler.Action.Action + {- ^ __Returns:__ the action to perform. The returned + object is owned by /@field@/ and should not be freed. -} +formFieldGetAdditionalAction field type_ = liftIO $ do + field' <- unsafeManagedPtrCastPtr field + let type_' = (fromIntegral . fromEnum) type_ + result <- poppler_form_field_get_additional_action field' type_' + checkUnexpectedReturnNULL "formFieldGetAdditionalAction" result + result' <- (newBoxed Poppler.Action.Action) result + touchManagedPtr field + return result' + +#if ENABLE_OVERLOADING +data FormFieldGetAdditionalActionMethodInfo +instance (signature ~ (Poppler.Enums.AdditionalActionType -> m Poppler.Action.Action), MonadIO m, IsFormField a) => O.MethodInfo FormFieldGetAdditionalActionMethodInfo a signature where + overloadedMethod _ = formFieldGetAdditionalAction + +#endif + +-- method FormField::get_field_type +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "field", argType = TInterface (Name {namespace = "Poppler", name = "FormField"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerFormField", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "FormFieldType"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_form_field_get_field_type" poppler_form_field_get_field_type :: + Ptr FormField -> -- field : TInterface (Name {namespace = "Poppler", name = "FormField"}) + IO CUInt + +{- | +Gets the type of /@field@/ +-} +formFieldGetFieldType :: + (B.CallStack.HasCallStack, MonadIO m, IsFormField a) => + a + {- ^ /@field@/: a 'GI.Poppler.Objects.FormField.FormField' -} + -> m Poppler.Enums.FormFieldType + {- ^ __Returns:__ 'GI.Poppler.Enums.FormFieldType' of /@field@/ -} +formFieldGetFieldType field = liftIO $ do + field' <- unsafeManagedPtrCastPtr field + result <- poppler_form_field_get_field_type field' + let result' = (toEnum . fromIntegral) result + touchManagedPtr field + return result' + +#if ENABLE_OVERLOADING +data FormFieldGetFieldTypeMethodInfo +instance (signature ~ (m Poppler.Enums.FormFieldType), MonadIO m, IsFormField a) => O.MethodInfo FormFieldGetFieldTypeMethodInfo a signature where + overloadedMethod _ = formFieldGetFieldType + +#endif + +-- method FormField::get_font_size +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "field", argType = TInterface (Name {namespace = "Poppler", name = "FormField"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerFormField", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TDouble) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_form_field_get_font_size" poppler_form_field_get_font_size :: + Ptr FormField -> -- field : TInterface (Name {namespace = "Poppler", name = "FormField"}) + IO CDouble + +{- | +Gets the font size of /@field@/ + +WARNING: This function always returns 0. Contact the poppler +mailing list if you\'re interested in implementing it properly +-} +formFieldGetFontSize :: + (B.CallStack.HasCallStack, MonadIO m, IsFormField a) => + a + {- ^ /@field@/: a 'GI.Poppler.Objects.FormField.FormField' -} + -> m Double + {- ^ __Returns:__ the font size of /@field@/ -} +formFieldGetFontSize field = liftIO $ do + field' <- unsafeManagedPtrCastPtr field + result <- poppler_form_field_get_font_size field' + let result' = realToFrac result + touchManagedPtr field + return result' + +#if ENABLE_OVERLOADING +data FormFieldGetFontSizeMethodInfo +instance (signature ~ (m Double), MonadIO m, IsFormField a) => O.MethodInfo FormFieldGetFontSizeMethodInfo a signature where + overloadedMethod _ = formFieldGetFontSize + +#endif + +-- method FormField::get_id +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "field", argType = TInterface (Name {namespace = "Poppler", name = "FormField"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerFormField", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_form_field_get_id" poppler_form_field_get_id :: + Ptr FormField -> -- field : TInterface (Name {namespace = "Poppler", name = "FormField"}) + IO Int32 + +{- | +Gets the id of /@field@/ +-} +formFieldGetId :: + (B.CallStack.HasCallStack, MonadIO m, IsFormField a) => + a + {- ^ /@field@/: a 'GI.Poppler.Objects.FormField.FormField' -} + -> m Int32 + {- ^ __Returns:__ the id of /@field@/ -} +formFieldGetId field = liftIO $ do + field' <- unsafeManagedPtrCastPtr field + result <- poppler_form_field_get_id field' + touchManagedPtr field + return result + +#if ENABLE_OVERLOADING +data FormFieldGetIdMethodInfo +instance (signature ~ (m Int32), MonadIO m, IsFormField a) => O.MethodInfo FormFieldGetIdMethodInfo a signature where + overloadedMethod _ = formFieldGetId + +#endif + +-- method FormField::get_mapping_name +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "field", argType = TInterface (Name {namespace = "Poppler", name = "FormField"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerFormField", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_form_field_get_mapping_name" poppler_form_field_get_mapping_name :: + Ptr FormField -> -- field : TInterface (Name {namespace = "Poppler", name = "FormField"}) + IO CString + +{- | +Gets the mapping name of /@field@/ that is used when +exporting interactive form field data from the document + +/Since: 0.16/ +-} +formFieldGetMappingName :: + (B.CallStack.HasCallStack, MonadIO m, IsFormField a) => + a + {- ^ /@field@/: a 'GI.Poppler.Objects.FormField.FormField' -} + -> m T.Text + {- ^ __Returns:__ a new allocated string. It must be freed with 'GI.GLib.Functions.free' when done. -} +formFieldGetMappingName field = liftIO $ do + field' <- unsafeManagedPtrCastPtr field + result <- poppler_form_field_get_mapping_name field' + checkUnexpectedReturnNULL "formFieldGetMappingName" result + result' <- cstringToText result + freeMem result + touchManagedPtr field + return result' + +#if ENABLE_OVERLOADING +data FormFieldGetMappingNameMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsFormField a) => O.MethodInfo FormFieldGetMappingNameMethodInfo a signature where + overloadedMethod _ = formFieldGetMappingName + +#endif + +-- method FormField::get_name +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "field", argType = TInterface (Name {namespace = "Poppler", name = "FormField"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerFormField", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_form_field_get_name" poppler_form_field_get_name :: + Ptr FormField -> -- field : TInterface (Name {namespace = "Poppler", name = "FormField"}) + IO CString + +{- | +Gets the fully qualified name of /@field@/. It\'s constructed by concatenating +the partial field names of the field and all of its ancestors. + +/Since: 0.16/ +-} +formFieldGetName :: + (B.CallStack.HasCallStack, MonadIO m, IsFormField a) => + a + {- ^ /@field@/: a 'GI.Poppler.Objects.FormField.FormField' -} + -> m T.Text + {- ^ __Returns:__ a new allocated string. It must be freed with 'GI.GLib.Functions.free' when done. -} +formFieldGetName field = liftIO $ do + field' <- unsafeManagedPtrCastPtr field + result <- poppler_form_field_get_name field' + checkUnexpectedReturnNULL "formFieldGetName" result + result' <- cstringToText result + freeMem result + touchManagedPtr field + return result' + +#if ENABLE_OVERLOADING +data FormFieldGetNameMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsFormField a) => O.MethodInfo FormFieldGetNameMethodInfo a signature where + overloadedMethod _ = formFieldGetName + +#endif + +-- method FormField::get_partial_name +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "field", argType = TInterface (Name {namespace = "Poppler", name = "FormField"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerFormField", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_form_field_get_partial_name" poppler_form_field_get_partial_name :: + Ptr FormField -> -- field : TInterface (Name {namespace = "Poppler", name = "FormField"}) + IO CString + +{- | +Gets the partial name of /@field@/. + +/Since: 0.16/ +-} +formFieldGetPartialName :: + (B.CallStack.HasCallStack, MonadIO m, IsFormField a) => + a + {- ^ /@field@/: a 'GI.Poppler.Objects.FormField.FormField' -} + -> m T.Text + {- ^ __Returns:__ a new allocated string. It must be freed with 'GI.GLib.Functions.free' when done. -} +formFieldGetPartialName field = liftIO $ do + field' <- unsafeManagedPtrCastPtr field + result <- poppler_form_field_get_partial_name field' + checkUnexpectedReturnNULL "formFieldGetPartialName" result + result' <- cstringToText result + freeMem result + touchManagedPtr field + return result' + +#if ENABLE_OVERLOADING +data FormFieldGetPartialNameMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsFormField a) => O.MethodInfo FormFieldGetPartialNameMethodInfo a signature where + overloadedMethod _ = formFieldGetPartialName + +#endif + +-- method FormField::is_read_only +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "field", argType = TInterface (Name {namespace = "Poppler", name = "FormField"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerFormField", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_form_field_is_read_only" poppler_form_field_is_read_only :: + Ptr FormField -> -- field : TInterface (Name {namespace = "Poppler", name = "FormField"}) + IO CInt + +{- | +Checks whether /@field@/ is read only +-} +formFieldIsReadOnly :: + (B.CallStack.HasCallStack, MonadIO m, IsFormField a) => + a + {- ^ /@field@/: a 'GI.Poppler.Objects.FormField.FormField' -} + -> m Bool + {- ^ __Returns:__ 'True' if /@field@/ is read only -} +formFieldIsReadOnly field = liftIO $ do + field' <- unsafeManagedPtrCastPtr field + result <- poppler_form_field_is_read_only field' + let result' = (/= 0) result + touchManagedPtr field + return result' + +#if ENABLE_OVERLOADING +data FormFieldIsReadOnlyMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsFormField a) => O.MethodInfo FormFieldIsReadOnlyMethodInfo a signature where + overloadedMethod _ = formFieldIsReadOnly + +#endif + +-- method FormField::text_do_scroll +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "field", argType = TInterface (Name {namespace = "Poppler", name = "FormField"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_form_field_text_do_scroll" poppler_form_field_text_do_scroll :: + Ptr FormField -> -- field : TInterface (Name {namespace = "Poppler", name = "FormField"}) + IO CInt + +{- | +/No description available in the introspection data./ +-} +formFieldTextDoScroll :: + (B.CallStack.HasCallStack, MonadIO m, IsFormField a) => + a + -> m Bool +formFieldTextDoScroll field = liftIO $ do + field' <- unsafeManagedPtrCastPtr field + result <- poppler_form_field_text_do_scroll field' + let result' = (/= 0) result + touchManagedPtr field + return result' + +#if ENABLE_OVERLOADING +data FormFieldTextDoScrollMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsFormField a) => O.MethodInfo FormFieldTextDoScrollMethodInfo a signature where + overloadedMethod _ = formFieldTextDoScroll + +#endif + +-- method FormField::text_do_spell_check +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "field", argType = TInterface (Name {namespace = "Poppler", name = "FormField"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerFormField", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_form_field_text_do_spell_check" poppler_form_field_text_do_spell_check :: + Ptr FormField -> -- field : TInterface (Name {namespace = "Poppler", name = "FormField"}) + IO CInt + +{- | +Checks whether spell checking should be done for the contents of /@field@/ +-} +formFieldTextDoSpellCheck :: + (B.CallStack.HasCallStack, MonadIO m, IsFormField a) => + a + {- ^ /@field@/: a 'GI.Poppler.Objects.FormField.FormField' -} + -> m Bool + {- ^ __Returns:__ 'True' if spell checking should be done for /@field@/ -} +formFieldTextDoSpellCheck field = liftIO $ do + field' <- unsafeManagedPtrCastPtr field + result <- poppler_form_field_text_do_spell_check field' + let result' = (/= 0) result + touchManagedPtr field + return result' + +#if ENABLE_OVERLOADING +data FormFieldTextDoSpellCheckMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsFormField a) => O.MethodInfo FormFieldTextDoSpellCheckMethodInfo a signature where + overloadedMethod _ = formFieldTextDoSpellCheck + +#endif + +-- method FormField::text_get_max_len +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "field", argType = TInterface (Name {namespace = "Poppler", name = "FormField"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerFormField", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_form_field_text_get_max_len" poppler_form_field_text_get_max_len :: + Ptr FormField -> -- field : TInterface (Name {namespace = "Poppler", name = "FormField"}) + IO Int32 + +{- | +Retrieves the maximum allowed length of the text in /@field@/ +-} +formFieldTextGetMaxLen :: + (B.CallStack.HasCallStack, MonadIO m, IsFormField a) => + a + {- ^ /@field@/: a 'GI.Poppler.Objects.FormField.FormField' -} + -> m Int32 + {- ^ __Returns:__ the maximum allowed number of characters in /@field@/, or -1 if there is no maximum. -} +formFieldTextGetMaxLen field = liftIO $ do + field' <- unsafeManagedPtrCastPtr field + result <- poppler_form_field_text_get_max_len field' + touchManagedPtr field + return result + +#if ENABLE_OVERLOADING +data FormFieldTextGetMaxLenMethodInfo +instance (signature ~ (m Int32), MonadIO m, IsFormField a) => O.MethodInfo FormFieldTextGetMaxLenMethodInfo a signature where + overloadedMethod _ = formFieldTextGetMaxLen + +#endif + +-- method FormField::text_get_text +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "field", argType = TInterface (Name {namespace = "Poppler", name = "FormField"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerFormField", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_form_field_text_get_text" poppler_form_field_text_get_text :: + Ptr FormField -> -- field : TInterface (Name {namespace = "Poppler", name = "FormField"}) + IO CString + +{- | +Retrieves the contents of /@field@/. +-} +formFieldTextGetText :: + (B.CallStack.HasCallStack, MonadIO m, IsFormField a) => + a + {- ^ /@field@/: a 'GI.Poppler.Objects.FormField.FormField' -} + -> m T.Text + {- ^ __Returns:__ a new allocated string. It must be freed with 'GI.GLib.Functions.free' when done. -} +formFieldTextGetText field = liftIO $ do + field' <- unsafeManagedPtrCastPtr field + result <- poppler_form_field_text_get_text field' + checkUnexpectedReturnNULL "formFieldTextGetText" result + result' <- cstringToText result + freeMem result + touchManagedPtr field + return result' + +#if ENABLE_OVERLOADING +data FormFieldTextGetTextMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsFormField a) => O.MethodInfo FormFieldTextGetTextMethodInfo a signature where + overloadedMethod _ = formFieldTextGetText + +#endif + +-- method FormField::text_get_text_type +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "field", argType = TInterface (Name {namespace = "Poppler", name = "FormField"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerFormField", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "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 -> -- field : TInterface (Name {namespace = "Poppler", name = "FormField"}) + IO CUInt + +{- | +Gets the text type of /@field@/. +-} +formFieldTextGetTextType :: + (B.CallStack.HasCallStack, MonadIO m, IsFormField a) => + a + {- ^ /@field@/: a 'GI.Poppler.Objects.FormField.FormField' -} + -> m Poppler.Enums.FormTextType + {- ^ __Returns:__ 'GI.Poppler.Enums.FormTextType' of /@field@/ -} +formFieldTextGetTextType field = liftIO $ do + field' <- unsafeManagedPtrCastPtr field + result <- poppler_form_field_text_get_text_type field' + let result' = (toEnum . fromIntegral) result + touchManagedPtr field + return result' + +#if ENABLE_OVERLOADING +data FormFieldTextGetTextTypeMethodInfo +instance (signature ~ (m Poppler.Enums.FormTextType), MonadIO m, IsFormField a) => O.MethodInfo FormFieldTextGetTextTypeMethodInfo a signature where + overloadedMethod _ = formFieldTextGetTextType + +#endif + +-- method FormField::text_is_password +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "field", argType = TInterface (Name {namespace = "Poppler", name = "FormField"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerFormField", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_form_field_text_is_password" poppler_form_field_text_is_password :: + Ptr FormField -> -- field : TInterface (Name {namespace = "Poppler", name = "FormField"}) + IO CInt + +{- | +Checks whether content of /@field@/ is a password and it must be hidden +-} +formFieldTextIsPassword :: + (B.CallStack.HasCallStack, MonadIO m, IsFormField a) => + a + {- ^ /@field@/: a 'GI.Poppler.Objects.FormField.FormField' -} + -> m Bool + {- ^ __Returns:__ 'True' if the content of /@field@/ is a password -} +formFieldTextIsPassword field = liftIO $ do + field' <- unsafeManagedPtrCastPtr field + result <- poppler_form_field_text_is_password field' + let result' = (/= 0) result + touchManagedPtr field + return result' + +#if ENABLE_OVERLOADING +data FormFieldTextIsPasswordMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsFormField a) => O.MethodInfo FormFieldTextIsPasswordMethodInfo a signature where + overloadedMethod _ = formFieldTextIsPassword + +#endif + +-- method FormField::text_is_rich_text +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "field", argType = TInterface (Name {namespace = "Poppler", name = "FormField"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerFormField", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_form_field_text_is_rich_text" poppler_form_field_text_is_rich_text :: + Ptr FormField -> -- field : TInterface (Name {namespace = "Poppler", name = "FormField"}) + IO CInt + +{- | +Checks whether the contents of /@field@/ are rich text +-} +formFieldTextIsRichText :: + (B.CallStack.HasCallStack, MonadIO m, IsFormField a) => + a + {- ^ /@field@/: a 'GI.Poppler.Objects.FormField.FormField' -} + -> m Bool + {- ^ __Returns:__ 'True' if the contents of /@field@/ are rich text -} +formFieldTextIsRichText field = liftIO $ do + field' <- unsafeManagedPtrCastPtr field + result <- poppler_form_field_text_is_rich_text field' + let result' = (/= 0) result + touchManagedPtr field + return result' + +#if ENABLE_OVERLOADING +data FormFieldTextIsRichTextMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsFormField a) => O.MethodInfo FormFieldTextIsRichTextMethodInfo a signature where + overloadedMethod _ = formFieldTextIsRichText + +#endif + +-- method FormField::text_set_text +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "field", argType = TInterface (Name {namespace = "Poppler", name = "FormField"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerFormField", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new text", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_form_field_text_set_text" poppler_form_field_text_set_text :: + Ptr FormField -> -- field : TInterface (Name {namespace = "Poppler", name = "FormField"}) + CString -> -- text : TBasicType TUTF8 + IO () + +{- | +Sets the text in /@field@/ to the given value, replacing the current contents. +-} +formFieldTextSetText :: + (B.CallStack.HasCallStack, MonadIO m, IsFormField a) => + a + {- ^ /@field@/: a 'GI.Poppler.Objects.FormField.FormField' -} + -> T.Text + {- ^ /@text@/: the new text -} + -> m () +formFieldTextSetText field text = liftIO $ do + field' <- unsafeManagedPtrCastPtr field + text' <- textToCString text + poppler_form_field_text_set_text field' text' + touchManagedPtr field + freeMem text' + return () + +#if ENABLE_OVERLOADING +data FormFieldTextSetTextMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsFormField a) => O.MethodInfo FormFieldTextSetTextMethodInfo a signature where + overloadedMethod _ = formFieldTextSetText + +#endif + + 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,128 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Poppler.Objects.FormField where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype FormField = FormField (ManagedPtr FormField) +instance GObject FormField where +class (GObject o, O.IsDescendantOf FormField o) => IsFormField o +instance (GObject o, O.IsDescendantOf FormField o) => IsFormField o +instance O.HasParentTypes FormField +#if ENABLE_OVERLOADING +data FormFieldButtonGetButtonTypeMethodInfo +#endif +#if ENABLE_OVERLOADING +data FormFieldButtonGetStateMethodInfo +#endif +#if ENABLE_OVERLOADING +data FormFieldButtonSetStateMethodInfo +#endif +#if ENABLE_OVERLOADING +data FormFieldChoiceCanSelectMultipleMethodInfo +#endif +#if ENABLE_OVERLOADING +data FormFieldChoiceCommitOnChangeMethodInfo +#endif +#if ENABLE_OVERLOADING +data FormFieldChoiceDoSpellCheckMethodInfo +#endif +#if ENABLE_OVERLOADING +data FormFieldChoiceGetChoiceTypeMethodInfo +#endif +#if ENABLE_OVERLOADING +data FormFieldChoiceGetItemMethodInfo +#endif +#if ENABLE_OVERLOADING +data FormFieldChoiceGetNItemsMethodInfo +#endif +#if ENABLE_OVERLOADING +data FormFieldChoiceGetTextMethodInfo +#endif +#if ENABLE_OVERLOADING +data FormFieldChoiceIsEditableMethodInfo +#endif +#if ENABLE_OVERLOADING +data FormFieldChoiceIsItemSelectedMethodInfo +#endif +#if ENABLE_OVERLOADING +data FormFieldChoiceSelectItemMethodInfo +#endif +#if ENABLE_OVERLOADING +data FormFieldChoiceSetTextMethodInfo +#endif +#if ENABLE_OVERLOADING +data FormFieldChoiceToggleItemMethodInfo +#endif +#if ENABLE_OVERLOADING +data FormFieldChoiceUnselectAllMethodInfo +#endif +#if ENABLE_OVERLOADING +data FormFieldGetActionMethodInfo +#endif +#if ENABLE_OVERLOADING +data FormFieldGetAdditionalActionMethodInfo +#endif +#if ENABLE_OVERLOADING +data FormFieldGetFieldTypeMethodInfo +#endif +#if ENABLE_OVERLOADING +data FormFieldGetFontSizeMethodInfo +#endif +#if ENABLE_OVERLOADING +data FormFieldGetIdMethodInfo +#endif +#if ENABLE_OVERLOADING +data FormFieldGetMappingNameMethodInfo +#endif +#if ENABLE_OVERLOADING +data FormFieldGetNameMethodInfo +#endif +#if ENABLE_OVERLOADING +data FormFieldGetPartialNameMethodInfo +#endif +#if ENABLE_OVERLOADING +data FormFieldIsReadOnlyMethodInfo +#endif +#if ENABLE_OVERLOADING +data FormFieldTextDoScrollMethodInfo +#endif +#if ENABLE_OVERLOADING +data FormFieldTextDoSpellCheckMethodInfo +#endif +#if ENABLE_OVERLOADING +data FormFieldTextGetMaxLenMethodInfo +#endif +#if ENABLE_OVERLOADING +data FormFieldTextGetTextMethodInfo +#endif +#if ENABLE_OVERLOADING +data FormFieldTextGetTextTypeMethodInfo +#endif +#if ENABLE_OVERLOADING +data FormFieldTextIsPasswordMethodInfo +#endif +#if ENABLE_OVERLOADING +data FormFieldTextIsRichTextMethodInfo +#endif +#if ENABLE_OVERLOADING +data FormFieldTextSetTextMethodInfo +#endif 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,400 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Poppler.Objects.Layer + ( + +-- * Exported types + Layer(..) , + IsLayer , + toLayer , + noLayer , + + + -- * Methods +-- ** getRadioButtonGroupId #method:getRadioButtonGroupId# + +#if ENABLE_OVERLOADING + LayerGetRadioButtonGroupIdMethodInfo , +#endif + layerGetRadioButtonGroupId , + + +-- ** getTitle #method:getTitle# + +#if ENABLE_OVERLOADING + LayerGetTitleMethodInfo , +#endif + layerGetTitle , + + +-- ** hide #method:hide# + +#if ENABLE_OVERLOADING + LayerHideMethodInfo , +#endif + layerHide , + + +-- ** isParent #method:isParent# + +#if ENABLE_OVERLOADING + LayerIsParentMethodInfo , +#endif + layerIsParent , + + +-- ** isVisible #method:isVisible# + +#if ENABLE_OVERLOADING + LayerIsVisibleMethodInfo , +#endif + layerIsVisible , + + +-- ** show #method:show# + +#if ENABLE_OVERLOADING + LayerShowMethodInfo , +#endif + layerShow , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import qualified GI.GObject.Objects.Object as GObject.Object + +-- | Memory-managed wrapper type. +newtype Layer = Layer (ManagedPtr Layer) +foreign import ccall "poppler_layer_get_type" + c_poppler_layer_get_type :: IO GType + +instance GObject Layer where + gobjectType = c_poppler_layer_get_type + + +-- | Type class for types which can be safely cast to `Layer`, for instance with `toLayer`. +class (GObject o, O.IsDescendantOf Layer o) => IsLayer o +instance (GObject o, O.IsDescendantOf Layer o) => IsLayer o + +instance O.HasParentTypes Layer +type instance O.ParentTypes Layer = '[GObject.Object.Object] + +-- | Cast to `Layer`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toLayer :: (MonadIO m, IsLayer o) => o -> m Layer +toLayer = liftIO . unsafeCastTo Layer + +-- | A convenience alias for `Nothing` :: `Maybe` `Layer`. +noLayer :: Maybe Layer +noLayer = Nothing + +#if ENABLE_OVERLOADING +type family ResolveLayerMethod (t :: Symbol) (o :: *) :: * where + ResolveLayerMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveLayerMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveLayerMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveLayerMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveLayerMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveLayerMethod "hide" o = LayerHideMethodInfo + ResolveLayerMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveLayerMethod "isParent" o = LayerIsParentMethodInfo + ResolveLayerMethod "isVisible" o = LayerIsVisibleMethodInfo + ResolveLayerMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveLayerMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveLayerMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveLayerMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveLayerMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveLayerMethod "show" o = LayerShowMethodInfo + ResolveLayerMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveLayerMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveLayerMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveLayerMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveLayerMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveLayerMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveLayerMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveLayerMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveLayerMethod "getRadioButtonGroupId" o = LayerGetRadioButtonGroupIdMethodInfo + ResolveLayerMethod "getTitle" o = LayerGetTitleMethodInfo + ResolveLayerMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveLayerMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveLayerMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveLayerMethod t Layer, O.MethodInfo info Layer p) => OL.IsLabel t (Layer -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList Layer +type instance O.AttributeList Layer = LayerAttributeList +type LayerAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList Layer = LayerSignalList +type LayerSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method Layer::get_radio_button_group_id +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "layer", argType = TInterface (Name {namespace = "Poppler", name = "Layer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerLayer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_layer_get_radio_button_group_id" poppler_layer_get_radio_button_group_id :: + Ptr Layer -> -- layer : TInterface (Name {namespace = "Poppler", name = "Layer"}) + IO Int32 + +{- | +Returns the numeric ID the radio button group associated with /@layer@/. + +/Since: 0.12/ +-} +layerGetRadioButtonGroupId :: + (B.CallStack.HasCallStack, MonadIO m, IsLayer a) => + a + {- ^ /@layer@/: a 'GI.Poppler.Objects.Layer.Layer' -} + -> m Int32 + {- ^ __Returns:__ the ID of the radio button group associated with /@layer@/, +or 0 if the layer is not associated to any radio button group -} +layerGetRadioButtonGroupId layer = liftIO $ do + layer' <- unsafeManagedPtrCastPtr layer + result <- poppler_layer_get_radio_button_group_id layer' + touchManagedPtr layer + return result + +#if ENABLE_OVERLOADING +data LayerGetRadioButtonGroupIdMethodInfo +instance (signature ~ (m Int32), MonadIO m, IsLayer a) => O.MethodInfo LayerGetRadioButtonGroupIdMethodInfo a signature where + overloadedMethod _ = layerGetRadioButtonGroupId + +#endif + +-- method Layer::get_title +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "layer", argType = TInterface (Name {namespace = "Poppler", name = "Layer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerLayer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_layer_get_title" poppler_layer_get_title :: + Ptr Layer -> -- layer : TInterface (Name {namespace = "Poppler", name = "Layer"}) + IO CString + +{- | +Returns the name of the layer suitable for +presentation as a title in a viewer\'s GUI + +/Since: 0.12/ +-} +layerGetTitle :: + (B.CallStack.HasCallStack, MonadIO m, IsLayer a) => + a + {- ^ /@layer@/: a 'GI.Poppler.Objects.Layer.Layer' -} + -> m T.Text + {- ^ __Returns:__ a string containing the title of the layer -} +layerGetTitle layer = liftIO $ do + layer' <- unsafeManagedPtrCastPtr layer + result <- poppler_layer_get_title layer' + checkUnexpectedReturnNULL "layerGetTitle" result + result' <- cstringToText result + touchManagedPtr layer + return result' + +#if ENABLE_OVERLOADING +data LayerGetTitleMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsLayer a) => O.MethodInfo LayerGetTitleMethodInfo a signature where + overloadedMethod _ = layerGetTitle + +#endif + +-- method Layer::hide +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "layer", argType = TInterface (Name {namespace = "Poppler", name = "Layer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerLayer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_layer_hide" poppler_layer_hide :: + Ptr Layer -> -- layer : TInterface (Name {namespace = "Poppler", name = "Layer"}) + IO () + +{- | +Hides /@layer@/. If /@layer@/ is the parent of other nested layers, +such layers will be also hidden and will be blocked until /@layer@/ +is shown again + +/Since: 0.12/ +-} +layerHide :: + (B.CallStack.HasCallStack, MonadIO m, IsLayer a) => + a + {- ^ /@layer@/: a 'GI.Poppler.Objects.Layer.Layer' -} + -> m () +layerHide layer = liftIO $ do + layer' <- unsafeManagedPtrCastPtr layer + poppler_layer_hide layer' + touchManagedPtr layer + return () + +#if ENABLE_OVERLOADING +data LayerHideMethodInfo +instance (signature ~ (m ()), MonadIO m, IsLayer a) => O.MethodInfo LayerHideMethodInfo a signature where + overloadedMethod _ = layerHide + +#endif + +-- method Layer::is_parent +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "layer", argType = TInterface (Name {namespace = "Poppler", name = "Layer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerLayer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_layer_is_parent" poppler_layer_is_parent :: + Ptr Layer -> -- layer : TInterface (Name {namespace = "Poppler", name = "Layer"}) + IO CInt + +{- | +Returns whether /@layer@/ is parent of other nested layers. + +/Since: 0.12/ +-} +layerIsParent :: + (B.CallStack.HasCallStack, MonadIO m, IsLayer a) => + a + {- ^ /@layer@/: a 'GI.Poppler.Objects.Layer.Layer' -} + -> m Bool + {- ^ __Returns:__ 'True' if /@layer@/ is a parent layer -} +layerIsParent layer = liftIO $ do + layer' <- unsafeManagedPtrCastPtr layer + result <- poppler_layer_is_parent layer' + let result' = (/= 0) result + touchManagedPtr layer + return result' + +#if ENABLE_OVERLOADING +data LayerIsParentMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsLayer a) => O.MethodInfo LayerIsParentMethodInfo a signature where + overloadedMethod _ = layerIsParent + +#endif + +-- method Layer::is_visible +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "layer", argType = TInterface (Name {namespace = "Poppler", name = "Layer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerLayer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_layer_is_visible" poppler_layer_is_visible :: + Ptr Layer -> -- layer : TInterface (Name {namespace = "Poppler", name = "Layer"}) + IO CInt + +{- | +Returns whether /@layer@/ is visible + +/Since: 0.12/ +-} +layerIsVisible :: + (B.CallStack.HasCallStack, MonadIO m, IsLayer a) => + a + {- ^ /@layer@/: a 'GI.Poppler.Objects.Layer.Layer' -} + -> m Bool + {- ^ __Returns:__ 'True' if /@layer@/ is visible -} +layerIsVisible layer = liftIO $ do + layer' <- unsafeManagedPtrCastPtr layer + result <- poppler_layer_is_visible layer' + let result' = (/= 0) result + touchManagedPtr layer + return result' + +#if ENABLE_OVERLOADING +data LayerIsVisibleMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsLayer a) => O.MethodInfo LayerIsVisibleMethodInfo a signature where + overloadedMethod _ = layerIsVisible + +#endif + +-- method Layer::show +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "layer", argType = TInterface (Name {namespace = "Poppler", name = "Layer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerLayer", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_layer_show" poppler_layer_show :: + Ptr Layer -> -- layer : TInterface (Name {namespace = "Poppler", name = "Layer"}) + IO () + +{- | +Shows /@layer@/ + +/Since: 0.12/ +-} +layerShow :: + (B.CallStack.HasCallStack, MonadIO m, IsLayer a) => + a + {- ^ /@layer@/: a 'GI.Poppler.Objects.Layer.Layer' -} + -> m () +layerShow layer = liftIO $ do + layer' <- unsafeManagedPtrCastPtr layer + poppler_layer_show layer' + touchManagedPtr layer + return () + +#if ENABLE_OVERLOADING +data LayerShowMethodInfo +instance (signature ~ (m ()), MonadIO m, IsLayer a) => O.MethodInfo LayerShowMethodInfo a signature where + overloadedMethod _ = layerShow + +#endif + + 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,47 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Poppler.Objects.Layer where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype Layer = Layer (ManagedPtr Layer) +instance GObject Layer where +class (GObject o, O.IsDescendantOf Layer o) => IsLayer o +instance (GObject o, O.IsDescendantOf Layer o) => IsLayer o +instance O.HasParentTypes Layer +#if ENABLE_OVERLOADING +data LayerGetRadioButtonGroupIdMethodInfo +#endif +#if ENABLE_OVERLOADING +data LayerGetTitleMethodInfo +#endif +#if ENABLE_OVERLOADING +data LayerHideMethodInfo +#endif +#if ENABLE_OVERLOADING +data LayerIsParentMethodInfo +#endif +#if ENABLE_OVERLOADING +data LayerIsVisibleMethodInfo +#endif +#if ENABLE_OVERLOADING +data LayerShowMethodInfo +#endif 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,388 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Poppler.Objects.Media + ( + +-- * Exported types + Media(..) , + IsMedia , + toMedia , + noMedia , + + + -- * Methods +-- ** getFilename #method:getFilename# + +#if ENABLE_OVERLOADING + MediaGetFilenameMethodInfo , +#endif + mediaGetFilename , + + +-- ** getMimeType #method:getMimeType# + +#if ENABLE_OVERLOADING + MediaGetMimeTypeMethodInfo , +#endif + mediaGetMimeType , + + +-- ** isEmbedded #method:isEmbedded# + +#if ENABLE_OVERLOADING + MediaIsEmbeddedMethodInfo , +#endif + mediaIsEmbedded , + + +-- ** save #method:save# + +#if ENABLE_OVERLOADING + MediaSaveMethodInfo , +#endif + mediaSave , + + +-- ** saveToCallback #method:saveToCallback# + +#if ENABLE_OVERLOADING + MediaSaveToCallbackMethodInfo , +#endif + mediaSaveToCallback , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import qualified GI.GObject.Objects.Object as GObject.Object +import qualified GI.Poppler.Callbacks as Poppler.Callbacks + +-- | Memory-managed wrapper type. +newtype Media = Media (ManagedPtr Media) +foreign import ccall "poppler_media_get_type" + c_poppler_media_get_type :: IO GType + +instance GObject Media where + gobjectType = c_poppler_media_get_type + + +-- | Type class for types which can be safely cast to `Media`, for instance with `toMedia`. +class (GObject o, O.IsDescendantOf Media o) => IsMedia o +instance (GObject o, O.IsDescendantOf Media o) => IsMedia o + +instance O.HasParentTypes Media +type instance O.ParentTypes Media = '[GObject.Object.Object] + +-- | Cast to `Media`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toMedia :: (MonadIO m, IsMedia o) => o -> m Media +toMedia = liftIO . unsafeCastTo Media + +-- | A convenience alias for `Nothing` :: `Maybe` `Media`. +noMedia :: Maybe Media +noMedia = Nothing + +#if ENABLE_OVERLOADING +type family ResolveMediaMethod (t :: Symbol) (o :: *) :: * where + ResolveMediaMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveMediaMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveMediaMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveMediaMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveMediaMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveMediaMethod "isEmbedded" o = MediaIsEmbeddedMethodInfo + ResolveMediaMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveMediaMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveMediaMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveMediaMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveMediaMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveMediaMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveMediaMethod "save" o = MediaSaveMethodInfo + ResolveMediaMethod "saveToCallback" o = MediaSaveToCallbackMethodInfo + ResolveMediaMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveMediaMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveMediaMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveMediaMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveMediaMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveMediaMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveMediaMethod "getFilename" o = MediaGetFilenameMethodInfo + ResolveMediaMethod "getMimeType" o = MediaGetMimeTypeMethodInfo + ResolveMediaMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveMediaMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveMediaMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveMediaMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveMediaMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveMediaMethod t Media, O.MethodInfo info Media p) => OL.IsLabel t (Media -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList Media +type instance O.AttributeList Media = MediaAttributeList +type MediaAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList Media = MediaSignalList +type MediaSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method Media::get_filename +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_media", argType = TInterface (Name {namespace = "Poppler", name = "Media"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerMedia", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_media_get_filename" poppler_media_get_filename :: + Ptr Media -> -- poppler_media : TInterface (Name {namespace = "Poppler", name = "Media"}) + IO CString + +{- | +Returns the media clip filename, in case of non-embedded media. filename might be +a local relative or absolute path or a URI + +/Since: 0.14/ +-} +mediaGetFilename :: + (B.CallStack.HasCallStack, MonadIO m, IsMedia a) => + a + {- ^ /@popplerMedia@/: a 'GI.Poppler.Objects.Media.Media' -} + -> m T.Text + {- ^ __Returns:__ a filename, return value is owned by 'GI.Poppler.Objects.Media.Media' and should not be freed -} +mediaGetFilename popplerMedia = liftIO $ do + popplerMedia' <- unsafeManagedPtrCastPtr popplerMedia + result <- poppler_media_get_filename popplerMedia' + checkUnexpectedReturnNULL "mediaGetFilename" result + result' <- cstringToText result + touchManagedPtr popplerMedia + return result' + +#if ENABLE_OVERLOADING +data MediaGetFilenameMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsMedia a) => O.MethodInfo MediaGetFilenameMethodInfo a signature where + overloadedMethod _ = mediaGetFilename + +#endif + +-- method Media::get_mime_type +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_media", argType = TInterface (Name {namespace = "Poppler", name = "Media"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerMedia", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_media_get_mime_type" poppler_media_get_mime_type :: + Ptr Media -> -- poppler_media : TInterface (Name {namespace = "Poppler", name = "Media"}) + IO CString + +{- | +Returns the media clip mime-type + +/Since: 0.14/ +-} +mediaGetMimeType :: + (B.CallStack.HasCallStack, MonadIO m, IsMedia a) => + a + {- ^ /@popplerMedia@/: a 'GI.Poppler.Objects.Media.Media' -} + -> m T.Text + {- ^ __Returns:__ the mime-type, return value is owned by 'GI.Poppler.Objects.Media.Media' and should not be freed -} +mediaGetMimeType popplerMedia = liftIO $ do + popplerMedia' <- unsafeManagedPtrCastPtr popplerMedia + result <- poppler_media_get_mime_type popplerMedia' + checkUnexpectedReturnNULL "mediaGetMimeType" result + result' <- cstringToText result + touchManagedPtr popplerMedia + return result' + +#if ENABLE_OVERLOADING +data MediaGetMimeTypeMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsMedia a) => O.MethodInfo MediaGetMimeTypeMethodInfo a signature where + overloadedMethod _ = mediaGetMimeType + +#endif + +-- method Media::is_embedded +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_media", argType = TInterface (Name {namespace = "Poppler", name = "Media"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerMedia", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_media_is_embedded" poppler_media_is_embedded :: + Ptr Media -> -- poppler_media : TInterface (Name {namespace = "Poppler", name = "Media"}) + IO CInt + +{- | +Whether the media clip is embedded in the PDF. If the result is 'True', the embedded stream +can be saved with 'GI.Poppler.Objects.Media.mediaSave' or 'GI.Poppler.Objects.Media.mediaSaveToCallback' function. +If the result is 'False', the media clip filename can be retrieved with +'GI.Poppler.Objects.Media.mediaGetFilename' function. + +/Since: 0.14/ +-} +mediaIsEmbedded :: + (B.CallStack.HasCallStack, MonadIO m, IsMedia a) => + a + {- ^ /@popplerMedia@/: a 'GI.Poppler.Objects.Media.Media' -} + -> m Bool + {- ^ __Returns:__ 'True' if media clip is embedded, 'False' otherwise -} +mediaIsEmbedded popplerMedia = liftIO $ do + popplerMedia' <- unsafeManagedPtrCastPtr popplerMedia + result <- poppler_media_is_embedded popplerMedia' + let result' = (/= 0) result + touchManagedPtr popplerMedia + return result' + +#if ENABLE_OVERLOADING +data MediaIsEmbeddedMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsMedia a) => O.MethodInfo MediaIsEmbeddedMethodInfo a signature where + overloadedMethod _ = mediaIsEmbedded + +#endif + +-- method Media::save +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_media", argType = TInterface (Name {namespace = "Poppler", name = "Media"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerMedia", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "filename", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "name of file to save", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "poppler_media_save" poppler_media_save :: + Ptr Media -> -- poppler_media : TInterface (Name {namespace = "Poppler", name = "Media"}) + CString -> -- filename : TBasicType TUTF8 + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Saves embedded stream of /@popplerMedia@/ to a file indicated by /@filename@/. +If /@error@/ is set, 'False' will be returned. +Possible errors include those in the @/G_FILE_ERROR/@ domain +and whatever the save function generates. + +/Since: 0.14/ +-} +mediaSave :: + (B.CallStack.HasCallStack, MonadIO m, IsMedia a) => + a + {- ^ /@popplerMedia@/: a 'GI.Poppler.Objects.Media.Media' -} + -> T.Text + {- ^ /@filename@/: name of file to save -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +mediaSave popplerMedia filename = liftIO $ do + popplerMedia' <- unsafeManagedPtrCastPtr popplerMedia + filename' <- textToCString filename + onException (do + _ <- propagateGError $ poppler_media_save popplerMedia' filename' + touchManagedPtr popplerMedia + freeMem filename' + return () + ) (do + freeMem filename' + ) + +#if ENABLE_OVERLOADING +data MediaSaveMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsMedia a) => O.MethodInfo MediaSaveMethodInfo a signature where + overloadedMethod _ = mediaSave + +#endif + +-- method Media::save_to_callback +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_media", argType = TInterface (Name {namespace = "Poppler", name = "Media"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerMedia", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "save_func", argType = TInterface (Name {namespace = "Poppler", name = "MediaSaveFunc"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a function that is called to save each block of data that the save routine generates.", sinceVersion = Nothing}, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data to pass to the save function.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : True +-- Skip return : False + +foreign import ccall "poppler_media_save_to_callback" poppler_media_save_to_callback :: + Ptr Media -> -- poppler_media : TInterface (Name {namespace = "Poppler", name = "Media"}) + FunPtr Poppler.Callbacks.C_MediaSaveFunc -> -- save_func : TInterface (Name {namespace = "Poppler", name = "MediaSaveFunc"}) + Ptr () -> -- user_data : TBasicType TPtr + Ptr (Ptr GError) -> -- error + IO CInt + +{- | +Saves embedded stream of /@popplerMedia@/ by feeding the produced data to /@saveFunc@/. Can be used +when you want to store the media clip stream to something other than a file, such as +an in-memory buffer or a socket. If /@error@/ is set, 'False' will be +returned. Possible errors include those in the @/G_FILE_ERROR/@ domain and +whatever the save function generates. + +/Since: 0.14/ +-} +mediaSaveToCallback :: + (B.CallStack.HasCallStack, MonadIO m, IsMedia a) => + a + {- ^ /@popplerMedia@/: a 'GI.Poppler.Objects.Media.Media' -} + -> FunPtr Poppler.Callbacks.C_MediaSaveFunc + {- ^ /@saveFunc@/: a function that is called to save each block of data that the save routine generates. -} + -> m () + {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} +mediaSaveToCallback popplerMedia saveFunc = liftIO $ do + popplerMedia' <- unsafeManagedPtrCastPtr popplerMedia + let userData = nullPtr + onException (do + _ <- propagateGError $ poppler_media_save_to_callback popplerMedia' saveFunc userData + safeFreeFunPtr $ castFunPtrToPtr saveFunc + touchManagedPtr popplerMedia + return () + ) (do + safeFreeFunPtr $ castFunPtrToPtr saveFunc + return () + ) + +#if ENABLE_OVERLOADING +data MediaSaveToCallbackMethodInfo +instance (signature ~ (FunPtr Poppler.Callbacks.C_MediaSaveFunc -> m ()), MonadIO m, IsMedia a) => O.MethodInfo MediaSaveToCallbackMethodInfo a signature where + overloadedMethod _ = mediaSaveToCallback + +#endif + + 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,44 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Poppler.Objects.Media where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype Media = Media (ManagedPtr Media) +instance GObject Media where +class (GObject o, O.IsDescendantOf Media o) => IsMedia o +instance (GObject o, O.IsDescendantOf Media o) => IsMedia o +instance O.HasParentTypes Media +#if ENABLE_OVERLOADING +data MediaGetFilenameMethodInfo +#endif +#if ENABLE_OVERLOADING +data MediaGetMimeTypeMethodInfo +#endif +#if ENABLE_OVERLOADING +data MediaIsEmbeddedMethodInfo +#endif +#if ENABLE_OVERLOADING +data MediaSaveMethodInfo +#endif +#if ENABLE_OVERLOADING +data MediaSaveToCallbackMethodInfo +#endif 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,313 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Poppler.Objects.Movie + ( + +-- * Exported types + Movie(..) , + IsMovie , + toMovie , + noMovie , + + + -- * Methods +-- ** getFilename #method:getFilename# + +#if ENABLE_OVERLOADING + MovieGetFilenameMethodInfo , +#endif + movieGetFilename , + + +-- ** getPlayMode #method:getPlayMode# + +#if ENABLE_OVERLOADING + MovieGetPlayModeMethodInfo , +#endif + movieGetPlayMode , + + +-- ** needPoster #method:needPoster# + +#if ENABLE_OVERLOADING + MovieNeedPosterMethodInfo , +#endif + movieNeedPoster , + + +-- ** showControls #method:showControls# + +#if ENABLE_OVERLOADING + MovieShowControlsMethodInfo , +#endif + movieShowControls , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import qualified GI.GObject.Objects.Object as GObject.Object +import {-# SOURCE #-} qualified GI.Poppler.Enums as Poppler.Enums + +-- | Memory-managed wrapper type. +newtype Movie = Movie (ManagedPtr Movie) +foreign import ccall "poppler_movie_get_type" + c_poppler_movie_get_type :: IO GType + +instance GObject Movie where + gobjectType = c_poppler_movie_get_type + + +-- | Type class for types which can be safely cast to `Movie`, for instance with `toMovie`. +class (GObject o, O.IsDescendantOf Movie o) => IsMovie o +instance (GObject o, O.IsDescendantOf Movie o) => IsMovie o + +instance O.HasParentTypes Movie +type instance O.ParentTypes Movie = '[GObject.Object.Object] + +-- | Cast to `Movie`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toMovie :: (MonadIO m, IsMovie o) => o -> m Movie +toMovie = liftIO . unsafeCastTo Movie + +-- | A convenience alias for `Nothing` :: `Maybe` `Movie`. +noMovie :: Maybe Movie +noMovie = Nothing + +#if ENABLE_OVERLOADING +type family ResolveMovieMethod (t :: Symbol) (o :: *) :: * where + ResolveMovieMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveMovieMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveMovieMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveMovieMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveMovieMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveMovieMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveMovieMethod "needPoster" o = MovieNeedPosterMethodInfo + ResolveMovieMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveMovieMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveMovieMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveMovieMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveMovieMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveMovieMethod "showControls" o = MovieShowControlsMethodInfo + ResolveMovieMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveMovieMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveMovieMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveMovieMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveMovieMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveMovieMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveMovieMethod "getFilename" o = MovieGetFilenameMethodInfo + ResolveMovieMethod "getPlayMode" o = MovieGetPlayModeMethodInfo + ResolveMovieMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveMovieMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveMovieMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveMovieMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveMovieMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveMovieMethod t Movie, O.MethodInfo info Movie p) => OL.IsLabel t (Movie -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList Movie +type instance O.AttributeList Movie = MovieAttributeList +type MovieAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList Movie = MovieSignalList +type MovieSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method Movie::get_filename +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_movie", argType = TInterface (Name {namespace = "Poppler", name = "Movie"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerMovie", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_movie_get_filename" poppler_movie_get_filename :: + Ptr Movie -> -- poppler_movie : TInterface (Name {namespace = "Poppler", name = "Movie"}) + IO CString + +{- | +Returns the local filename identifying a self-describing movie file + +/Since: 0.14/ +-} +movieGetFilename :: + (B.CallStack.HasCallStack, MonadIO m, IsMovie a) => + a + {- ^ /@popplerMovie@/: a 'GI.Poppler.Objects.Movie.Movie' -} + -> m T.Text + {- ^ __Returns:__ a local filename, return value is owned by 'GI.Poppler.Objects.Movie.Movie' and + should not be freed -} +movieGetFilename popplerMovie = liftIO $ do + popplerMovie' <- unsafeManagedPtrCastPtr popplerMovie + result <- poppler_movie_get_filename popplerMovie' + checkUnexpectedReturnNULL "movieGetFilename" result + result' <- cstringToText result + touchManagedPtr popplerMovie + return result' + +#if ENABLE_OVERLOADING +data MovieGetFilenameMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsMovie a) => O.MethodInfo MovieGetFilenameMethodInfo a signature where + overloadedMethod _ = movieGetFilename + +#endif + +-- method Movie::get_play_mode +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_movie", argType = TInterface (Name {namespace = "Poppler", name = "Movie"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerMovie", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "MoviePlayMode"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_movie_get_play_mode" poppler_movie_get_play_mode :: + Ptr Movie -> -- poppler_movie : TInterface (Name {namespace = "Poppler", name = "Movie"}) + IO CUInt + +{- | +Returns the play mode of /@popplerMovie@/. + +/Since: 0.54/ +-} +movieGetPlayMode :: + (B.CallStack.HasCallStack, MonadIO m, IsMovie a) => + a + {- ^ /@popplerMovie@/: a 'GI.Poppler.Objects.Movie.Movie' -} + -> m Poppler.Enums.MoviePlayMode + {- ^ __Returns:__ a 'GI.Poppler.Enums.MoviePlayMode'. -} +movieGetPlayMode popplerMovie = liftIO $ do + popplerMovie' <- unsafeManagedPtrCastPtr popplerMovie + result <- poppler_movie_get_play_mode popplerMovie' + let result' = (toEnum . fromIntegral) result + touchManagedPtr popplerMovie + return result' + +#if ENABLE_OVERLOADING +data MovieGetPlayModeMethodInfo +instance (signature ~ (m Poppler.Enums.MoviePlayMode), MonadIO m, IsMovie a) => O.MethodInfo MovieGetPlayModeMethodInfo a signature where + overloadedMethod _ = movieGetPlayMode + +#endif + +-- method Movie::need_poster +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_movie", argType = TInterface (Name {namespace = "Poppler", name = "Movie"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerMovie", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_movie_need_poster" poppler_movie_need_poster :: + Ptr Movie -> -- poppler_movie : TInterface (Name {namespace = "Poppler", name = "Movie"}) + IO CInt + +{- | +Returns whether a poster image representing the Movie +shall be displayed. The poster image must be retrieved +from the movie file. + +/Since: 0.14/ +-} +movieNeedPoster :: + (B.CallStack.HasCallStack, MonadIO m, IsMovie a) => + a + {- ^ /@popplerMovie@/: a 'GI.Poppler.Objects.Movie.Movie' -} + -> m Bool + {- ^ __Returns:__ 'True' if move needs a poster image, 'False' otherwise -} +movieNeedPoster popplerMovie = liftIO $ do + popplerMovie' <- unsafeManagedPtrCastPtr popplerMovie + result <- poppler_movie_need_poster popplerMovie' + let result' = (/= 0) result + touchManagedPtr popplerMovie + return result' + +#if ENABLE_OVERLOADING +data MovieNeedPosterMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsMovie a) => O.MethodInfo MovieNeedPosterMethodInfo a signature where + overloadedMethod _ = movieNeedPoster + +#endif + +-- method Movie::show_controls +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_movie", argType = TInterface (Name {namespace = "Poppler", name = "Movie"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerMovie", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_movie_show_controls" poppler_movie_show_controls :: + Ptr Movie -> -- poppler_movie : TInterface (Name {namespace = "Poppler", name = "Movie"}) + IO CInt + +{- | +Returns whether to display a movie controller bar while playing the movie + +/Since: 0.14/ +-} +movieShowControls :: + (B.CallStack.HasCallStack, MonadIO m, IsMovie a) => + a + {- ^ /@popplerMovie@/: a 'GI.Poppler.Objects.Movie.Movie' -} + -> m Bool + {- ^ __Returns:__ 'True' if controller bar should be displayed, 'False' otherwise -} +movieShowControls popplerMovie = liftIO $ do + popplerMovie' <- unsafeManagedPtrCastPtr popplerMovie + result <- poppler_movie_show_controls popplerMovie' + let result' = (/= 0) result + touchManagedPtr popplerMovie + return result' + +#if ENABLE_OVERLOADING +data MovieShowControlsMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsMovie a) => O.MethodInfo MovieShowControlsMethodInfo a signature where + overloadedMethod _ = movieShowControls + +#endif + + 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,41 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Poppler.Objects.Movie where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype Movie = Movie (ManagedPtr Movie) +instance GObject Movie where +class (GObject o, O.IsDescendantOf Movie o) => IsMovie o +instance (GObject o, O.IsDescendantOf Movie o) => IsMovie o +instance O.HasParentTypes Movie +#if ENABLE_OVERLOADING +data MovieGetFilenameMethodInfo +#endif +#if ENABLE_OVERLOADING +data MovieGetPlayModeMethodInfo +#endif +#if ENABLE_OVERLOADING +data MovieNeedPosterMethodInfo +#endif +#if ENABLE_OVERLOADING +data MovieShowControlsMethodInfo +#endif 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,313 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Poppler.Objects.PSFile + ( + +-- * Exported types + PSFile(..) , + IsPSFile , + toPSFile , + noPSFile , + + + -- * Methods +-- ** free #method:free# + +#if ENABLE_OVERLOADING + PSFileFreeMethodInfo , +#endif + pSFileFree , + + +-- ** new #method:new# + + pSFileNew , + + +-- ** setDuplex #method:setDuplex# + +#if ENABLE_OVERLOADING + PSFileSetDuplexMethodInfo , +#endif + pSFileSetDuplex , + + +-- ** setPaperSize #method:setPaperSize# + +#if ENABLE_OVERLOADING + PSFileSetPaperSizeMethodInfo , +#endif + pSFileSetPaperSize , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import qualified GI.GObject.Objects.Object as GObject.Object +import {-# SOURCE #-} qualified GI.Poppler.Objects.Document as Poppler.Document + +-- | Memory-managed wrapper type. +newtype PSFile = PSFile (ManagedPtr PSFile) +foreign import ccall "poppler_ps_file_get_type" + c_poppler_ps_file_get_type :: IO GType + +instance GObject PSFile where + gobjectType = c_poppler_ps_file_get_type + + +-- | Type class for types which can be safely cast to `PSFile`, for instance with `toPSFile`. +class (GObject o, O.IsDescendantOf PSFile o) => IsPSFile o +instance (GObject o, O.IsDescendantOf PSFile o) => IsPSFile o + +instance O.HasParentTypes PSFile +type instance O.ParentTypes PSFile = '[GObject.Object.Object] + +-- | Cast to `PSFile`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toPSFile :: (MonadIO m, IsPSFile o) => o -> m PSFile +toPSFile = liftIO . unsafeCastTo PSFile + +-- | A convenience alias for `Nothing` :: `Maybe` `PSFile`. +noPSFile :: Maybe PSFile +noPSFile = Nothing + +#if ENABLE_OVERLOADING +type family ResolvePSFileMethod (t :: Symbol) (o :: *) :: * where + ResolvePSFileMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolvePSFileMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolvePSFileMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolvePSFileMethod "free" o = PSFileFreeMethodInfo + ResolvePSFileMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolvePSFileMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolvePSFileMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolvePSFileMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolvePSFileMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolvePSFileMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolvePSFileMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolvePSFileMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolvePSFileMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolvePSFileMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolvePSFileMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolvePSFileMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolvePSFileMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolvePSFileMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolvePSFileMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolvePSFileMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolvePSFileMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolvePSFileMethod "setDuplex" o = PSFileSetDuplexMethodInfo + ResolvePSFileMethod "setPaperSize" o = PSFileSetPaperSizeMethodInfo + ResolvePSFileMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolvePSFileMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolvePSFileMethod t PSFile, O.MethodInfo info PSFile p) => OL.IsLabel t (PSFile -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList PSFile +type instance O.AttributeList PSFile = PSFileAttributeList +type PSFileAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList PSFile = PSFileSignalList +type PSFileSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method PSFile::new +-- method type : Constructor +-- Args : [Arg {argCName = "document", argType = TInterface (Name {namespace = "Poppler", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "filename", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the path of the output filename", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "first_page", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the first page to print", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_pages", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of pages to print", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "PSFile"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_ps_file_new" poppler_ps_file_new :: + Ptr Poppler.Document.Document -> -- document : TInterface (Name {namespace = "Poppler", name = "Document"}) + CString -> -- filename : TBasicType TUTF8 + Int32 -> -- first_page : TBasicType TInt + Int32 -> -- n_pages : TBasicType TInt + IO (Ptr PSFile) + +{- | +Create a new postscript file to render to +-} +pSFileNew :: + (B.CallStack.HasCallStack, MonadIO m, Poppler.Document.IsDocument a) => + a + {- ^ /@document@/: a 'GI.Poppler.Objects.Document.Document' -} + -> T.Text + {- ^ /@filename@/: the path of the output filename -} + -> Int32 + {- ^ /@firstPage@/: the first page to print -} + -> Int32 + {- ^ /@nPages@/: the number of pages to print -} + -> m PSFile + {- ^ __Returns:__ a PopplerPSFile -} +pSFileNew document filename firstPage nPages = liftIO $ do + document' <- unsafeManagedPtrCastPtr document + filename' <- textToCString filename + result <- poppler_ps_file_new document' filename' firstPage nPages + checkUnexpectedReturnNULL "pSFileNew" result + result' <- (wrapObject PSFile) result + touchManagedPtr document + freeMem filename' + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method PSFile::free +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "ps_file", argType = TInterface (Name {namespace = "Poppler", name = "PSFile"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a PopplerPSFile", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_ps_file_free" poppler_ps_file_free :: + Ptr PSFile -> -- ps_file : TInterface (Name {namespace = "Poppler", name = "PSFile"}) + IO () + +{- | +Frees /@psFile@/ +-} +pSFileFree :: + (B.CallStack.HasCallStack, MonadIO m, IsPSFile a) => + a + {- ^ /@psFile@/: a PopplerPSFile -} + -> m () +pSFileFree psFile = liftIO $ do + psFile' <- unsafeManagedPtrCastPtr psFile + poppler_ps_file_free psFile' + touchManagedPtr psFile + return () + +#if ENABLE_OVERLOADING +data PSFileFreeMethodInfo +instance (signature ~ (m ()), MonadIO m, IsPSFile a) => O.MethodInfo PSFileFreeMethodInfo a signature where + overloadedMethod _ = pSFileFree + +#endif + +-- method PSFile::set_duplex +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "ps_file", argType = TInterface (Name {namespace = "Poppler", name = "PSFile"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a PopplerPSFile which was not yet printed to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "duplex", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether to force duplex printing (on printers which support this)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_ps_file_set_duplex" poppler_ps_file_set_duplex :: + Ptr PSFile -> -- ps_file : TInterface (Name {namespace = "Poppler", name = "PSFile"}) + CInt -> -- duplex : TBasicType TBoolean + IO () + +{- | +Enable or disable Duplex printing. +-} +pSFileSetDuplex :: + (B.CallStack.HasCallStack, MonadIO m, IsPSFile a) => + a + {- ^ /@psFile@/: a PopplerPSFile which was not yet printed to -} + -> Bool + {- ^ /@duplex@/: whether to force duplex printing (on printers which support this) -} + -> m () +pSFileSetDuplex psFile duplex = liftIO $ do + psFile' <- unsafeManagedPtrCastPtr psFile + let duplex' = (fromIntegral . fromEnum) duplex + poppler_ps_file_set_duplex psFile' duplex' + touchManagedPtr psFile + return () + +#if ENABLE_OVERLOADING +data PSFileSetDuplexMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsPSFile a) => O.MethodInfo PSFileSetDuplexMethodInfo a signature where + overloadedMethod _ = pSFileSetDuplex + +#endif + +-- method PSFile::set_paper_size +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "ps_file", argType = TInterface (Name {namespace = "Poppler", name = "PSFile"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a PopplerPSFile which was not yet printed to.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the paper width in 1/72 inch", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "height", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the paper height in 1/72 inch", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_ps_file_set_paper_size" poppler_ps_file_set_paper_size :: + Ptr PSFile -> -- ps_file : TInterface (Name {namespace = "Poppler", name = "PSFile"}) + CDouble -> -- width : TBasicType TDouble + CDouble -> -- height : TBasicType TDouble + IO () + +{- | +Set the output paper size. These values will end up in the +DocumentMedia, the BoundingBox DSC comments and other places in the +generated PostScript. +-} +pSFileSetPaperSize :: + (B.CallStack.HasCallStack, MonadIO m, IsPSFile a) => + a + {- ^ /@psFile@/: a PopplerPSFile which was not yet printed to. -} + -> Double + {- ^ /@width@/: the paper width in 1\/72 inch -} + -> Double + {- ^ /@height@/: the paper height in 1\/72 inch -} + -> m () +pSFileSetPaperSize psFile width height = liftIO $ do + psFile' <- unsafeManagedPtrCastPtr psFile + let width' = realToFrac width + let height' = realToFrac height + poppler_ps_file_set_paper_size psFile' width' height' + touchManagedPtr psFile + return () + +#if ENABLE_OVERLOADING +data PSFileSetPaperSizeMethodInfo +instance (signature ~ (Double -> Double -> m ()), MonadIO m, IsPSFile a) => O.MethodInfo PSFileSetPaperSizeMethodInfo a signature where + overloadedMethod _ = pSFileSetPaperSize + +#endif + + 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,38 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Poppler.Objects.PSFile where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype PSFile = PSFile (ManagedPtr PSFile) +instance GObject PSFile where +class (GObject o, O.IsDescendantOf PSFile o) => IsPSFile o +instance (GObject o, O.IsDescendantOf PSFile o) => IsPSFile o +instance O.HasParentTypes PSFile +#if ENABLE_OVERLOADING +data PSFileFreeMethodInfo +#endif +#if ENABLE_OVERLOADING +data PSFileSetDuplexMethodInfo +#endif +#if ENABLE_OVERLOADING +data PSFileSetPaperSizeMethodInfo +#endif 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,2057 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Poppler.Objects.Page + ( + +-- * Exported types + Page(..) , + IsPage , + toPage , + noPage , + + + -- * Methods +-- ** addAnnot #method:addAnnot# + +#if ENABLE_OVERLOADING + PageAddAnnotMethodInfo , +#endif + pageAddAnnot , + + +-- ** findText #method:findText# + +#if ENABLE_OVERLOADING + PageFindTextMethodInfo , +#endif + pageFindText , + + +-- ** findTextWithOptions #method:findTextWithOptions# + +#if ENABLE_OVERLOADING + PageFindTextWithOptionsMethodInfo , +#endif + pageFindTextWithOptions , + + +-- ** freeAnnotMapping #method:freeAnnotMapping# + + pageFreeAnnotMapping , + + +-- ** freeFormFieldMapping #method:freeFormFieldMapping# + + pageFreeFormFieldMapping , + + +-- ** freeImageMapping #method:freeImageMapping# + + pageFreeImageMapping , + + +-- ** freeLinkMapping #method:freeLinkMapping# + + pageFreeLinkMapping , + + +-- ** freeTextAttributes #method:freeTextAttributes# + + pageFreeTextAttributes , + + +-- ** getAnnotMapping #method:getAnnotMapping# + +#if ENABLE_OVERLOADING + PageGetAnnotMappingMethodInfo , +#endif + pageGetAnnotMapping , + + +-- ** getCropBox #method:getCropBox# + +#if ENABLE_OVERLOADING + PageGetCropBoxMethodInfo , +#endif + pageGetCropBox , + + +-- ** getDuration #method:getDuration# + +#if ENABLE_OVERLOADING + PageGetDurationMethodInfo , +#endif + pageGetDuration , + + +-- ** getFormFieldMapping #method:getFormFieldMapping# + +#if ENABLE_OVERLOADING + PageGetFormFieldMappingMethodInfo , +#endif + pageGetFormFieldMapping , + + +-- ** getImage #method:getImage# + +#if ENABLE_OVERLOADING + PageGetImageMethodInfo , +#endif + pageGetImage , + + +-- ** getImageMapping #method:getImageMapping# + +#if ENABLE_OVERLOADING + PageGetImageMappingMethodInfo , +#endif + pageGetImageMapping , + + +-- ** getIndex #method:getIndex# + +#if ENABLE_OVERLOADING + PageGetIndexMethodInfo , +#endif + pageGetIndex , + + +-- ** getLabel #method:getLabel# + +#if ENABLE_OVERLOADING + PageGetLabelMethodInfo , +#endif + pageGetLabel , + + +-- ** getLinkMapping #method:getLinkMapping# + +#if ENABLE_OVERLOADING + PageGetLinkMappingMethodInfo , +#endif + pageGetLinkMapping , + + +-- ** getSelectedRegion #method:getSelectedRegion# + +#if ENABLE_OVERLOADING + PageGetSelectedRegionMethodInfo , +#endif + pageGetSelectedRegion , + + +-- ** getSelectedText #method:getSelectedText# + +#if ENABLE_OVERLOADING + PageGetSelectedTextMethodInfo , +#endif + pageGetSelectedText , + + +-- ** getSelectionRegion #method:getSelectionRegion# + +#if ENABLE_OVERLOADING + PageGetSelectionRegionMethodInfo , +#endif + pageGetSelectionRegion , + + +-- ** getSize #method:getSize# + +#if ENABLE_OVERLOADING + PageGetSizeMethodInfo , +#endif + pageGetSize , + + +-- ** getText #method:getText# + +#if ENABLE_OVERLOADING + PageGetTextMethodInfo , +#endif + pageGetText , + + +-- ** getTextAttributes #method:getTextAttributes# + +#if ENABLE_OVERLOADING + PageGetTextAttributesMethodInfo , +#endif + pageGetTextAttributes , + + +-- ** getTextAttributesForArea #method:getTextAttributesForArea# + +#if ENABLE_OVERLOADING + PageGetTextAttributesForAreaMethodInfo , +#endif + pageGetTextAttributesForArea , + + +-- ** getTextForArea #method:getTextForArea# + +#if ENABLE_OVERLOADING + PageGetTextForAreaMethodInfo , +#endif + pageGetTextForArea , + + +-- ** getTextLayout #method:getTextLayout# + +#if ENABLE_OVERLOADING + PageGetTextLayoutMethodInfo , +#endif + pageGetTextLayout , + + +-- ** getTextLayoutForArea #method:getTextLayoutForArea# + +#if ENABLE_OVERLOADING + PageGetTextLayoutForAreaMethodInfo , +#endif + pageGetTextLayoutForArea , + + +-- ** getThumbnail #method:getThumbnail# + +#if ENABLE_OVERLOADING + PageGetThumbnailMethodInfo , +#endif + pageGetThumbnail , + + +-- ** getThumbnailSize #method:getThumbnailSize# + +#if ENABLE_OVERLOADING + PageGetThumbnailSizeMethodInfo , +#endif + pageGetThumbnailSize , + + +-- ** getTransition #method:getTransition# + +#if ENABLE_OVERLOADING + PageGetTransitionMethodInfo , +#endif + pageGetTransition , + + +-- ** removeAnnot #method:removeAnnot# + +#if ENABLE_OVERLOADING + PageRemoveAnnotMethodInfo , +#endif + pageRemoveAnnot , + + +-- ** render #method:render# + +#if ENABLE_OVERLOADING + PageRenderMethodInfo , +#endif + pageRender , + + +-- ** renderForPrinting #method:renderForPrinting# + +#if ENABLE_OVERLOADING + PageRenderForPrintingMethodInfo , +#endif + pageRenderForPrinting , + + +-- ** renderForPrintingWithOptions #method:renderForPrintingWithOptions# + +#if ENABLE_OVERLOADING + PageRenderForPrintingWithOptionsMethodInfo, +#endif + pageRenderForPrintingWithOptions , + + +-- ** renderSelection #method:renderSelection# + +#if ENABLE_OVERLOADING + PageRenderSelectionMethodInfo , +#endif + pageRenderSelection , + + +-- ** renderToPs #method:renderToPs# + +#if ENABLE_OVERLOADING + PageRenderToPsMethodInfo , +#endif + pageRenderToPs , + + +-- ** selectionRegionFree #method:selectionRegionFree# + + pageSelectionRegionFree , + + + + + -- * Properties +-- ** label #attr:label# +{- | The label of the page or 'Nothing'. See also 'GI.Poppler.Objects.Page.pageGetLabel' +-} +#if ENABLE_OVERLOADING + PageLabelPropertyInfo , +#endif + getPageLabel , +#if ENABLE_OVERLOADING + pageLabel , +#endif + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import qualified GI.Cairo.Structs.Context as Cairo.Context +import qualified GI.Cairo.Structs.Region as Cairo.Region +import qualified GI.Cairo.Structs.Surface as Cairo.Surface +import qualified GI.GObject.Objects.Object as GObject.Object +import {-# SOURCE #-} qualified GI.Poppler.Enums as Poppler.Enums +import {-# SOURCE #-} qualified GI.Poppler.Flags as Poppler.Flags +import {-# SOURCE #-} qualified GI.Poppler.Objects.Annot as Poppler.Annot +import {-# SOURCE #-} qualified GI.Poppler.Objects.PSFile as Poppler.PSFile +import {-# SOURCE #-} qualified GI.Poppler.Structs.AnnotMapping as Poppler.AnnotMapping +import {-# SOURCE #-} qualified GI.Poppler.Structs.Color as Poppler.Color +import {-# SOURCE #-} qualified GI.Poppler.Structs.FormFieldMapping as Poppler.FormFieldMapping +import {-# SOURCE #-} qualified GI.Poppler.Structs.ImageMapping as Poppler.ImageMapping +import {-# SOURCE #-} qualified GI.Poppler.Structs.LinkMapping as Poppler.LinkMapping +import {-# SOURCE #-} qualified GI.Poppler.Structs.PageTransition as Poppler.PageTransition +import {-# SOURCE #-} qualified GI.Poppler.Structs.Rectangle as Poppler.Rectangle +import {-# SOURCE #-} qualified GI.Poppler.Structs.TextAttributes as Poppler.TextAttributes + +-- | Memory-managed wrapper type. +newtype Page = Page (ManagedPtr Page) +foreign import ccall "poppler_page_get_type" + c_poppler_page_get_type :: IO GType + +instance GObject Page where + gobjectType = c_poppler_page_get_type + + +-- | Type class for types which can be safely cast to `Page`, for instance with `toPage`. +class (GObject o, O.IsDescendantOf Page o) => IsPage o +instance (GObject o, O.IsDescendantOf Page o) => IsPage o + +instance O.HasParentTypes Page +type instance O.ParentTypes Page = '[GObject.Object.Object] + +-- | Cast to `Page`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toPage :: (MonadIO m, IsPage o) => o -> m Page +toPage = liftIO . unsafeCastTo Page + +-- | A convenience alias for `Nothing` :: `Maybe` `Page`. +noPage :: Maybe Page +noPage = Nothing + +#if ENABLE_OVERLOADING +type family ResolvePageMethod (t :: Symbol) (o :: *) :: * where + ResolvePageMethod "addAnnot" o = PageAddAnnotMethodInfo + ResolvePageMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolvePageMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolvePageMethod "findText" o = PageFindTextMethodInfo + ResolvePageMethod "findTextWithOptions" o = PageFindTextWithOptionsMethodInfo + ResolvePageMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolvePageMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolvePageMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolvePageMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolvePageMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolvePageMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolvePageMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolvePageMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolvePageMethod "removeAnnot" o = PageRemoveAnnotMethodInfo + ResolvePageMethod "render" o = PageRenderMethodInfo + ResolvePageMethod "renderForPrinting" o = PageRenderForPrintingMethodInfo + ResolvePageMethod "renderForPrintingWithOptions" o = PageRenderForPrintingWithOptionsMethodInfo + ResolvePageMethod "renderSelection" o = PageRenderSelectionMethodInfo + ResolvePageMethod "renderToPs" o = PageRenderToPsMethodInfo + ResolvePageMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolvePageMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolvePageMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolvePageMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolvePageMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolvePageMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolvePageMethod "getAnnotMapping" o = PageGetAnnotMappingMethodInfo + ResolvePageMethod "getCropBox" o = PageGetCropBoxMethodInfo + ResolvePageMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolvePageMethod "getDuration" o = PageGetDurationMethodInfo + ResolvePageMethod "getFormFieldMapping" o = PageGetFormFieldMappingMethodInfo + ResolvePageMethod "getImage" o = PageGetImageMethodInfo + ResolvePageMethod "getImageMapping" o = PageGetImageMappingMethodInfo + ResolvePageMethod "getIndex" o = PageGetIndexMethodInfo + ResolvePageMethod "getLabel" o = PageGetLabelMethodInfo + ResolvePageMethod "getLinkMapping" o = PageGetLinkMappingMethodInfo + ResolvePageMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolvePageMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolvePageMethod "getSelectedRegion" o = PageGetSelectedRegionMethodInfo + ResolvePageMethod "getSelectedText" o = PageGetSelectedTextMethodInfo + ResolvePageMethod "getSelectionRegion" o = PageGetSelectionRegionMethodInfo + ResolvePageMethod "getSize" o = PageGetSizeMethodInfo + ResolvePageMethod "getText" o = PageGetTextMethodInfo + ResolvePageMethod "getTextAttributes" o = PageGetTextAttributesMethodInfo + ResolvePageMethod "getTextAttributesForArea" o = PageGetTextAttributesForAreaMethodInfo + ResolvePageMethod "getTextForArea" o = PageGetTextForAreaMethodInfo + ResolvePageMethod "getTextLayout" o = PageGetTextLayoutMethodInfo + ResolvePageMethod "getTextLayoutForArea" o = PageGetTextLayoutForAreaMethodInfo + ResolvePageMethod "getThumbnail" o = PageGetThumbnailMethodInfo + ResolvePageMethod "getThumbnailSize" o = PageGetThumbnailSizeMethodInfo + ResolvePageMethod "getTransition" o = PageGetTransitionMethodInfo + ResolvePageMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolvePageMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolvePageMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolvePageMethod t Page, O.MethodInfo info Page p) => OL.IsLabel t (Page -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + +-- VVV Prop "label" + -- Type: TBasicType TUTF8 + -- Flags: [PropertyReadable] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@label@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' page #label +@ +-} +getPageLabel :: (MonadIO m, IsPage o) => o -> m (Maybe T.Text) +getPageLabel obj = liftIO $ B.Properties.getObjectPropertyString obj "label" + +#if ENABLE_OVERLOADING +data PageLabelPropertyInfo +instance AttrInfo PageLabelPropertyInfo where + type AttrAllowedOps PageLabelPropertyInfo = '[ 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint PageLabelPropertyInfo = (~) () + type AttrBaseTypeConstraint PageLabelPropertyInfo = IsPage + type AttrGetType PageLabelPropertyInfo = (Maybe T.Text) + type AttrLabel PageLabelPropertyInfo = "label" + type AttrOrigin PageLabelPropertyInfo = Page + attrGet _ = getPageLabel + attrSet _ = undefined + attrConstruct _ = undefined + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList Page +type instance O.AttributeList Page = PageAttributeList +type PageAttributeList = ('[ '("label", PageLabelPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +pageLabel :: AttrLabelProxy "label" +pageLabel = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList Page = PageSignalList +type PageSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method Page::add_annot +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "page", argType = TInterface (Name {namespace = "Poppler", name = "Page"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerPage", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "annot", argType = TInterface (Name {namespace = "Poppler", name = "Annot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerAnnot to add", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_page_add_annot" poppler_page_add_annot :: + Ptr Page -> -- page : TInterface (Name {namespace = "Poppler", name = "Page"}) + Ptr Poppler.Annot.Annot -> -- annot : TInterface (Name {namespace = "Poppler", name = "Annot"}) + IO () + +{- | +Adds annotation /@annot@/ to /@page@/. + +/Since: 0.16/ +-} +pageAddAnnot :: + (B.CallStack.HasCallStack, MonadIO m, IsPage a, Poppler.Annot.IsAnnot b) => + a + {- ^ /@page@/: a 'GI.Poppler.Objects.Page.Page' -} + -> b + {- ^ /@annot@/: a 'GI.Poppler.Objects.Annot.Annot' to add -} + -> m () +pageAddAnnot page annot = liftIO $ do + page' <- unsafeManagedPtrCastPtr page + annot' <- unsafeManagedPtrCastPtr annot + poppler_page_add_annot page' annot' + touchManagedPtr page + touchManagedPtr annot + return () + +#if ENABLE_OVERLOADING +data PageAddAnnotMethodInfo +instance (signature ~ (b -> m ()), MonadIO m, IsPage a, Poppler.Annot.IsAnnot b) => O.MethodInfo PageAddAnnotMethodInfo a signature where + overloadedMethod _ = pageAddAnnot + +#endif + +-- method Page::find_text +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "page", argType = TInterface (Name {namespace = "Poppler", name = "Page"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerPage", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the text to search for (UTF-8 encoded)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TGList (TInterface (Name {namespace = "Poppler", name = "Rectangle"}))) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_page_find_text" poppler_page_find_text :: + Ptr Page -> -- page : TInterface (Name {namespace = "Poppler", name = "Page"}) + CString -> -- text : TBasicType TUTF8 + IO (Ptr (GList (Ptr Poppler.Rectangle.Rectangle))) + +{- | +Finds /@text@/ in /@page@/ with the default options ('GI.Poppler.Flags.FindFlagsDefault') and +returns a 'GI.GLib.Structs.List.List' of rectangles for each occurrence of the text on the page. +The coordinates are in PDF points. +-} +pageFindText :: + (B.CallStack.HasCallStack, MonadIO m, IsPage a) => + a + {- ^ /@page@/: a 'GI.Poppler.Objects.Page.Page' -} + -> T.Text + {- ^ /@text@/: the text to search for (UTF-8 encoded) -} + -> m [Poppler.Rectangle.Rectangle] + {- ^ __Returns:__ a 'GI.GLib.Structs.List.List' of 'GI.Poppler.Structs.Rectangle.Rectangle', -} +pageFindText page text = liftIO $ do + page' <- unsafeManagedPtrCastPtr page + text' <- textToCString text + result <- poppler_page_find_text page' text' + result' <- unpackGList result + result'' <- mapM (wrapBoxed Poppler.Rectangle.Rectangle) result' + g_list_free result + touchManagedPtr page + freeMem text' + return result'' + +#if ENABLE_OVERLOADING +data PageFindTextMethodInfo +instance (signature ~ (T.Text -> m [Poppler.Rectangle.Rectangle]), MonadIO m, IsPage a) => O.MethodInfo PageFindTextMethodInfo a signature where + overloadedMethod _ = pageFindText + +#endif + +-- method Page::find_text_with_options +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "page", argType = TInterface (Name {namespace = "Poppler", name = "Page"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerPage", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the text to search for (UTF-8 encoded)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "options", argType = TInterface (Name {namespace = "Poppler", name = "FindFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "find options", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TGList (TInterface (Name {namespace = "Poppler", name = "Rectangle"}))) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_page_find_text_with_options" poppler_page_find_text_with_options :: + Ptr Page -> -- page : TInterface (Name {namespace = "Poppler", name = "Page"}) + CString -> -- text : TBasicType TUTF8 + CUInt -> -- options : TInterface (Name {namespace = "Poppler", name = "FindFlags"}) + IO (Ptr (GList (Ptr Poppler.Rectangle.Rectangle))) + +{- | +Finds /@text@/ in /@page@/ with the given 'GI.Poppler.Flags.FindFlags' options and +returns a 'GI.GLib.Structs.List.List' of rectangles for each occurrence of the text on the page. +The coordinates are in PDF points. + +/Since: 0.22/ +-} +pageFindTextWithOptions :: + (B.CallStack.HasCallStack, MonadIO m, IsPage a) => + a + {- ^ /@page@/: a 'GI.Poppler.Objects.Page.Page' -} + -> T.Text + {- ^ /@text@/: the text to search for (UTF-8 encoded) -} + -> [Poppler.Flags.FindFlags] + {- ^ /@options@/: find options -} + -> m [Poppler.Rectangle.Rectangle] + {- ^ __Returns:__ a 'GI.GLib.Structs.List.List' of 'GI.Poppler.Structs.Rectangle.Rectangle', -} +pageFindTextWithOptions page text options = liftIO $ do + page' <- unsafeManagedPtrCastPtr page + text' <- textToCString text + let options' = gflagsToWord options + result <- poppler_page_find_text_with_options page' text' options' + result' <- unpackGList result + result'' <- mapM (wrapBoxed Poppler.Rectangle.Rectangle) result' + g_list_free result + touchManagedPtr page + freeMem text' + return result'' + +#if ENABLE_OVERLOADING +data PageFindTextWithOptionsMethodInfo +instance (signature ~ (T.Text -> [Poppler.Flags.FindFlags] -> m [Poppler.Rectangle.Rectangle]), MonadIO m, IsPage a) => O.MethodInfo PageFindTextWithOptionsMethodInfo a signature where + overloadedMethod _ = pageFindTextWithOptions + +#endif + +-- method Page::get_annot_mapping +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "page", argType = TInterface (Name {namespace = "Poppler", name = "Page"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerPage", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TGList (TInterface (Name {namespace = "Poppler", name = "AnnotMapping"}))) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_page_get_annot_mapping" poppler_page_get_annot_mapping :: + Ptr Page -> -- page : TInterface (Name {namespace = "Poppler", name = "Page"}) + IO (Ptr (GList (Ptr Poppler.AnnotMapping.AnnotMapping))) + +{- | +Returns a list of 'GI.Poppler.Structs.AnnotMapping.AnnotMapping' items that map from a location on +/@page@/ to a 'GI.Poppler.Objects.Annot.Annot'. This list must be freed with +'GI.Poppler.Objects.Page.pageFreeAnnotMapping' when done. +-} +pageGetAnnotMapping :: + (B.CallStack.HasCallStack, MonadIO m, IsPage a) => + a + {- ^ /@page@/: A 'GI.Poppler.Objects.Page.Page' -} + -> m [Poppler.AnnotMapping.AnnotMapping] + {- ^ __Returns:__ A 'GI.GLib.Structs.List.List' of 'GI.Poppler.Structs.AnnotMapping.AnnotMapping' -} +pageGetAnnotMapping page = liftIO $ do + page' <- unsafeManagedPtrCastPtr page + result <- poppler_page_get_annot_mapping page' + result' <- unpackGList result + result'' <- mapM (wrapBoxed Poppler.AnnotMapping.AnnotMapping) result' + g_list_free result + touchManagedPtr page + return result'' + +#if ENABLE_OVERLOADING +data PageGetAnnotMappingMethodInfo +instance (signature ~ (m [Poppler.AnnotMapping.AnnotMapping]), MonadIO m, IsPage a) => O.MethodInfo PageGetAnnotMappingMethodInfo a signature where + overloadedMethod _ = pageGetAnnotMapping + +#endif + +-- method Page::get_crop_box +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "page", argType = TInterface (Name {namespace = "Poppler", name = "Page"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerPage", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rect", argType = TInterface (Name {namespace = "Poppler", name = "Rectangle"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerRectangle to fill", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_page_get_crop_box" poppler_page_get_crop_box :: + Ptr Page -> -- page : TInterface (Name {namespace = "Poppler", name = "Page"}) + Ptr Poppler.Rectangle.Rectangle -> -- rect : TInterface (Name {namespace = "Poppler", name = "Rectangle"}) + IO () + +{- | +Retrurns the crop box of /@page@/ +-} +pageGetCropBox :: + (B.CallStack.HasCallStack, MonadIO m, IsPage a) => + a + {- ^ /@page@/: a 'GI.Poppler.Objects.Page.Page' -} + -> m (Poppler.Rectangle.Rectangle) +pageGetCropBox page = liftIO $ do + page' <- unsafeManagedPtrCastPtr page + rect <- callocBoxedBytes 32 :: IO (Ptr Poppler.Rectangle.Rectangle) + poppler_page_get_crop_box page' rect + rect' <- (wrapBoxed Poppler.Rectangle.Rectangle) rect + touchManagedPtr page + return rect' + +#if ENABLE_OVERLOADING +data PageGetCropBoxMethodInfo +instance (signature ~ (m (Poppler.Rectangle.Rectangle)), MonadIO m, IsPage a) => O.MethodInfo PageGetCropBoxMethodInfo a signature where + overloadedMethod _ = pageGetCropBox + +#endif + +-- method Page::get_duration +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "page", argType = TInterface (Name {namespace = "Poppler", name = "Page"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerPage", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TDouble) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_page_get_duration" poppler_page_get_duration :: + Ptr Page -> -- page : TInterface (Name {namespace = "Poppler", name = "Page"}) + IO CDouble + +{- | +Returns the duration of /@page@/ +-} +pageGetDuration :: + (B.CallStack.HasCallStack, MonadIO m, IsPage a) => + a + {- ^ /@page@/: a 'GI.Poppler.Objects.Page.Page' -} + -> m Double + {- ^ __Returns:__ duration in seconds of /@page@/ or -1. -} +pageGetDuration page = liftIO $ do + page' <- unsafeManagedPtrCastPtr page + result <- poppler_page_get_duration page' + let result' = realToFrac result + touchManagedPtr page + return result' + +#if ENABLE_OVERLOADING +data PageGetDurationMethodInfo +instance (signature ~ (m Double), MonadIO m, IsPage a) => O.MethodInfo PageGetDurationMethodInfo a signature where + overloadedMethod _ = pageGetDuration + +#endif + +-- method Page::get_form_field_mapping +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "page", argType = TInterface (Name {namespace = "Poppler", name = "Page"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerPage", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TGList (TInterface (Name {namespace = "Poppler", name = "FormFieldMapping"}))) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_page_get_form_field_mapping" poppler_page_get_form_field_mapping :: + Ptr Page -> -- page : TInterface (Name {namespace = "Poppler", name = "Page"}) + IO (Ptr (GList (Ptr Poppler.FormFieldMapping.FormFieldMapping))) + +{- | +Returns a list of 'GI.Poppler.Structs.FormFieldMapping.FormFieldMapping' items that map from a +location on /@page@/ to a form field. This list must be freed +with 'GI.Poppler.Objects.Page.pageFreeFormFieldMapping' when done. +-} +pageGetFormFieldMapping :: + (B.CallStack.HasCallStack, MonadIO m, IsPage a) => + a + {- ^ /@page@/: A 'GI.Poppler.Objects.Page.Page' -} + -> m [Poppler.FormFieldMapping.FormFieldMapping] + {- ^ __Returns:__ A 'GI.GLib.Structs.List.List' of 'GI.Poppler.Structs.FormFieldMapping.FormFieldMapping' -} +pageGetFormFieldMapping page = liftIO $ do + page' <- unsafeManagedPtrCastPtr page + result <- poppler_page_get_form_field_mapping page' + result' <- unpackGList result + result'' <- mapM (wrapBoxed Poppler.FormFieldMapping.FormFieldMapping) result' + g_list_free result + touchManagedPtr page + return result'' + +#if ENABLE_OVERLOADING +data PageGetFormFieldMappingMethodInfo +instance (signature ~ (m [Poppler.FormFieldMapping.FormFieldMapping]), MonadIO m, IsPage a) => O.MethodInfo PageGetFormFieldMappingMethodInfo a signature where + overloadedMethod _ = pageGetFormFieldMapping + +#endif + +-- method Page::get_image +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "page", argType = TInterface (Name {namespace = "Poppler", name = "Page"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerPage", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "image_id", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The image identifier", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "cairo", name = "Surface"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_page_get_image" poppler_page_get_image :: + Ptr Page -> -- page : TInterface (Name {namespace = "Poppler", name = "Page"}) + Int32 -> -- image_id : TBasicType TInt + IO (Ptr Cairo.Surface.Surface) + +{- | +Returns a cairo surface for the image of the /@page@/ +-} +pageGetImage :: + (B.CallStack.HasCallStack, MonadIO m, IsPage a) => + a + {- ^ /@page@/: A 'GI.Poppler.Objects.Page.Page' -} + -> Int32 + {- ^ /@imageId@/: The image identifier -} + -> m Cairo.Surface.Surface + {- ^ __Returns:__ A cairo surface for the image -} +pageGetImage page imageId = liftIO $ do + page' <- unsafeManagedPtrCastPtr page + result <- poppler_page_get_image page' imageId + checkUnexpectedReturnNULL "pageGetImage" result + result' <- (wrapBoxed Cairo.Surface.Surface) result + touchManagedPtr page + return result' + +#if ENABLE_OVERLOADING +data PageGetImageMethodInfo +instance (signature ~ (Int32 -> m Cairo.Surface.Surface), MonadIO m, IsPage a) => O.MethodInfo PageGetImageMethodInfo a signature where + overloadedMethod _ = pageGetImage + +#endif + +-- method Page::get_image_mapping +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "page", argType = TInterface (Name {namespace = "Poppler", name = "Page"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerPage", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TGList (TInterface (Name {namespace = "Poppler", name = "ImageMapping"}))) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_page_get_image_mapping" poppler_page_get_image_mapping :: + Ptr Page -> -- page : TInterface (Name {namespace = "Poppler", name = "Page"}) + IO (Ptr (GList (Ptr Poppler.ImageMapping.ImageMapping))) + +{- | +Returns a list of 'GI.Poppler.Structs.ImageMapping.ImageMapping' items that map from a +location on /@page@/ to an image of the page. This list must be freed +with 'GI.Poppler.Objects.Page.pageFreeImageMapping' when done. +-} +pageGetImageMapping :: + (B.CallStack.HasCallStack, MonadIO m, IsPage a) => + a + {- ^ /@page@/: A 'GI.Poppler.Objects.Page.Page' -} + -> m [Poppler.ImageMapping.ImageMapping] + {- ^ __Returns:__ A 'GI.GLib.Structs.List.List' of 'GI.Poppler.Structs.ImageMapping.ImageMapping' -} +pageGetImageMapping page = liftIO $ do + page' <- unsafeManagedPtrCastPtr page + result <- poppler_page_get_image_mapping page' + result' <- unpackGList result + result'' <- mapM (wrapBoxed Poppler.ImageMapping.ImageMapping) result' + g_list_free result + touchManagedPtr page + return result'' + +#if ENABLE_OVERLOADING +data PageGetImageMappingMethodInfo +instance (signature ~ (m [Poppler.ImageMapping.ImageMapping]), MonadIO m, IsPage a) => O.MethodInfo PageGetImageMappingMethodInfo a signature where + overloadedMethod _ = pageGetImageMapping + +#endif + +-- method Page::get_index +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "page", argType = TInterface (Name {namespace = "Poppler", name = "Page"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerPage", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_page_get_index" poppler_page_get_index :: + Ptr Page -> -- page : TInterface (Name {namespace = "Poppler", name = "Page"}) + IO Int32 + +{- | +Returns the index of /@page@/ +-} +pageGetIndex :: + (B.CallStack.HasCallStack, MonadIO m, IsPage a) => + a + {- ^ /@page@/: a 'GI.Poppler.Objects.Page.Page' -} + -> m Int32 + {- ^ __Returns:__ index value of /@page@/ -} +pageGetIndex page = liftIO $ do + page' <- unsafeManagedPtrCastPtr page + result <- poppler_page_get_index page' + touchManagedPtr page + return result + +#if ENABLE_OVERLOADING +data PageGetIndexMethodInfo +instance (signature ~ (m Int32), MonadIO m, IsPage a) => O.MethodInfo PageGetIndexMethodInfo a signature where + overloadedMethod _ = pageGetIndex + +#endif + +-- method Page::get_label +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "page", argType = TInterface (Name {namespace = "Poppler", name = "Page"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerPage", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_page_get_label" poppler_page_get_label :: + Ptr Page -> -- page : TInterface (Name {namespace = "Poppler", name = "Page"}) + IO CString + +{- | +Returns the label of /@page@/. Note that page labels +and page indices might not coincide. + +/Since: 0.16/ +-} +pageGetLabel :: + (B.CallStack.HasCallStack, MonadIO m, IsPage a) => + a + {- ^ /@page@/: a 'GI.Poppler.Objects.Page.Page' -} + -> m T.Text + {- ^ __Returns:__ a new allocated string containing the label of /@page@/, + or 'Nothing' if /@page@/ doesn\'t have a label -} +pageGetLabel page = liftIO $ do + page' <- unsafeManagedPtrCastPtr page + result <- poppler_page_get_label page' + checkUnexpectedReturnNULL "pageGetLabel" result + result' <- cstringToText result + freeMem result + touchManagedPtr page + return result' + +#if ENABLE_OVERLOADING +data PageGetLabelMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsPage a) => O.MethodInfo PageGetLabelMethodInfo a signature where + overloadedMethod _ = pageGetLabel + +#endif + +-- method Page::get_link_mapping +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "page", argType = TInterface (Name {namespace = "Poppler", name = "Page"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerPage", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TGList (TInterface (Name {namespace = "Poppler", name = "LinkMapping"}))) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_page_get_link_mapping" poppler_page_get_link_mapping :: + Ptr Page -> -- page : TInterface (Name {namespace = "Poppler", name = "Page"}) + IO (Ptr (GList (Ptr Poppler.LinkMapping.LinkMapping))) + +{- | +Returns a list of 'GI.Poppler.Structs.LinkMapping.LinkMapping' items that map from a +location on /@page@/ to a 'GI.Poppler.Unions.Action.Action'. This list must be freed +with 'GI.Poppler.Objects.Page.pageFreeLinkMapping' when done. +-} +pageGetLinkMapping :: + (B.CallStack.HasCallStack, MonadIO m, IsPage a) => + a + {- ^ /@page@/: A 'GI.Poppler.Objects.Page.Page' -} + -> m [Poppler.LinkMapping.LinkMapping] + {- ^ __Returns:__ A 'GI.GLib.Structs.List.List' of 'GI.Poppler.Structs.LinkMapping.LinkMapping' -} +pageGetLinkMapping page = liftIO $ do + page' <- unsafeManagedPtrCastPtr page + result <- poppler_page_get_link_mapping page' + result' <- unpackGList result + result'' <- mapM (wrapBoxed Poppler.LinkMapping.LinkMapping) result' + g_list_free result + touchManagedPtr page + return result'' + +#if ENABLE_OVERLOADING +data PageGetLinkMappingMethodInfo +instance (signature ~ (m [Poppler.LinkMapping.LinkMapping]), MonadIO m, IsPage a) => O.MethodInfo PageGetLinkMappingMethodInfo a signature where + overloadedMethod _ = pageGetLinkMapping + +#endif + +-- method Page::get_selected_region +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "page", argType = TInterface (Name {namespace = "Poppler", name = "Page"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerPage", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "scale", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "scale specified as pixels per point", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "style", argType = TInterface (Name {namespace = "Poppler", name = "SelectionStyle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerSelectionStyle", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "selection", argType = TInterface (Name {namespace = "Poppler", name = "Rectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "start and end point of selection as a rectangle", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "cairo", name = "Region"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_page_get_selected_region" poppler_page_get_selected_region :: + Ptr Page -> -- page : TInterface (Name {namespace = "Poppler", name = "Page"}) + CDouble -> -- scale : TBasicType TDouble + CUInt -> -- style : TInterface (Name {namespace = "Poppler", name = "SelectionStyle"}) + Ptr Poppler.Rectangle.Rectangle -> -- selection : TInterface (Name {namespace = "Poppler", name = "Rectangle"}) + IO (Ptr Cairo.Region.Region) + +{- | +Returns a region containing the area that would be rendered by +'GI.Poppler.Objects.Page.pageRenderSelection'. +The returned region must be freed with @/cairo_region_destroy()/@ + +/Since: 0.16/ +-} +pageGetSelectedRegion :: + (B.CallStack.HasCallStack, MonadIO m, IsPage a) => + a + {- ^ /@page@/: a 'GI.Poppler.Objects.Page.Page' -} + -> Double + {- ^ /@scale@/: scale specified as pixels per point -} + -> Poppler.Enums.SelectionStyle + {- ^ /@style@/: a 'GI.Poppler.Enums.SelectionStyle' -} + -> Poppler.Rectangle.Rectangle + {- ^ /@selection@/: start and end point of selection as a rectangle -} + -> m Cairo.Region.Region + {- ^ __Returns:__ a cairo_region_t -} +pageGetSelectedRegion page scale style selection = liftIO $ do + page' <- unsafeManagedPtrCastPtr page + let scale' = realToFrac scale + let style' = (fromIntegral . fromEnum) style + selection' <- unsafeManagedPtrGetPtr selection + result <- poppler_page_get_selected_region page' scale' style' selection' + checkUnexpectedReturnNULL "pageGetSelectedRegion" result + result' <- (wrapBoxed Cairo.Region.Region) result + touchManagedPtr page + touchManagedPtr selection + return result' + +#if ENABLE_OVERLOADING +data PageGetSelectedRegionMethodInfo +instance (signature ~ (Double -> Poppler.Enums.SelectionStyle -> Poppler.Rectangle.Rectangle -> m Cairo.Region.Region), MonadIO m, IsPage a) => O.MethodInfo PageGetSelectedRegionMethodInfo a signature where + overloadedMethod _ = pageGetSelectedRegion + +#endif + +-- method Page::get_selected_text +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "page", argType = TInterface (Name {namespace = "Poppler", name = "Page"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerPage", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "style", argType = TInterface (Name {namespace = "Poppler", name = "SelectionStyle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerSelectionStyle", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "selection", argType = TInterface (Name {namespace = "Poppler", name = "Rectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #PopplerRectangle including the text", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_page_get_selected_text" poppler_page_get_selected_text :: + Ptr Page -> -- page : TInterface (Name {namespace = "Poppler", name = "Page"}) + CUInt -> -- style : TInterface (Name {namespace = "Poppler", name = "SelectionStyle"}) + Ptr Poppler.Rectangle.Rectangle -> -- selection : TInterface (Name {namespace = "Poppler", name = "Rectangle"}) + IO CString + +{- | +Retrieves the contents of the specified /@selection@/ as text. + +/Since: 0.16/ +-} +pageGetSelectedText :: + (B.CallStack.HasCallStack, MonadIO m, IsPage a) => + a + {- ^ /@page@/: a 'GI.Poppler.Objects.Page.Page' -} + -> Poppler.Enums.SelectionStyle + {- ^ /@style@/: a 'GI.Poppler.Enums.SelectionStyle' -} + -> Poppler.Rectangle.Rectangle + {- ^ /@selection@/: the 'GI.Poppler.Structs.Rectangle.Rectangle' including the text -} + -> m T.Text + {- ^ __Returns:__ a pointer to the contents of the /@selection@/ + as a string -} +pageGetSelectedText page style selection = liftIO $ do + page' <- unsafeManagedPtrCastPtr page + let style' = (fromIntegral . fromEnum) style + selection' <- unsafeManagedPtrGetPtr selection + result <- poppler_page_get_selected_text page' style' selection' + checkUnexpectedReturnNULL "pageGetSelectedText" result + result' <- cstringToText result + freeMem result + touchManagedPtr page + touchManagedPtr selection + return result' + +#if ENABLE_OVERLOADING +data PageGetSelectedTextMethodInfo +instance (signature ~ (Poppler.Enums.SelectionStyle -> Poppler.Rectangle.Rectangle -> m T.Text), MonadIO m, IsPage a) => O.MethodInfo PageGetSelectedTextMethodInfo a signature where + overloadedMethod _ = pageGetSelectedText + +#endif + +-- method Page::get_selection_region +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "page", argType = TInterface (Name {namespace = "Poppler", name = "Page"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerPage", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "scale", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "scale specified as pixels per point", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "style", argType = TInterface (Name {namespace = "Poppler", name = "SelectionStyle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerSelectionStyle", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "selection", argType = TInterface (Name {namespace = "Poppler", name = "Rectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "start and end point of selection as a rectangle", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TGList (TInterface (Name {namespace = "Poppler", name = "Rectangle"}))) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_page_get_selection_region" poppler_page_get_selection_region :: + Ptr Page -> -- page : TInterface (Name {namespace = "Poppler", name = "Page"}) + CDouble -> -- scale : TBasicType TDouble + CUInt -> -- style : TInterface (Name {namespace = "Poppler", name = "SelectionStyle"}) + Ptr Poppler.Rectangle.Rectangle -> -- selection : TInterface (Name {namespace = "Poppler", name = "Rectangle"}) + IO (Ptr (GList (Ptr Poppler.Rectangle.Rectangle))) + +{-# DEPRECATED pageGetSelectionRegion ["(Since version 0.16)","Use 'GI.Poppler.Objects.Page.pageGetSelectedRegion' instead."] #-} +{- | +Returns a region containing the area that would be rendered by +'GI.Poppler.Objects.Page.pageRenderSelection' as a 'GI.GLib.Structs.List.List' of +'GI.Poppler.Structs.Rectangle.Rectangle'. The returned list must be freed with +'GI.Poppler.Objects.Page.pageSelectionRegionFree'. +-} +pageGetSelectionRegion :: + (B.CallStack.HasCallStack, MonadIO m, IsPage a) => + a + {- ^ /@page@/: a 'GI.Poppler.Objects.Page.Page' -} + -> Double + {- ^ /@scale@/: scale specified as pixels per point -} + -> Poppler.Enums.SelectionStyle + {- ^ /@style@/: a 'GI.Poppler.Enums.SelectionStyle' -} + -> Poppler.Rectangle.Rectangle + {- ^ /@selection@/: start and end point of selection as a rectangle -} + -> m [Poppler.Rectangle.Rectangle] + {- ^ __Returns:__ a 'GI.GLib.Structs.List.List' of 'GI.Poppler.Structs.Rectangle.Rectangle' -} +pageGetSelectionRegion page scale style selection = liftIO $ do + page' <- unsafeManagedPtrCastPtr page + let scale' = realToFrac scale + let style' = (fromIntegral . fromEnum) style + selection' <- unsafeManagedPtrGetPtr selection + result <- poppler_page_get_selection_region page' scale' style' selection' + result' <- unpackGList result + result'' <- mapM (wrapBoxed Poppler.Rectangle.Rectangle) result' + g_list_free result + touchManagedPtr page + touchManagedPtr selection + return result'' + +#if ENABLE_OVERLOADING +data PageGetSelectionRegionMethodInfo +instance (signature ~ (Double -> Poppler.Enums.SelectionStyle -> Poppler.Rectangle.Rectangle -> m [Poppler.Rectangle.Rectangle]), MonadIO m, IsPage a) => O.MethodInfo PageGetSelectionRegionMethodInfo a signature where + overloadedMethod _ = pageGetSelectionRegion + +#endif + +-- method Page::get_size +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "page", argType = TInterface (Name {namespace = "Poppler", name = "Page"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerPage", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the width of @page", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "height", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the height of @page", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_page_get_size" poppler_page_get_size :: + Ptr Page -> -- page : TInterface (Name {namespace = "Poppler", name = "Page"}) + Ptr CDouble -> -- width : TBasicType TDouble + Ptr CDouble -> -- height : TBasicType TDouble + IO () + +{- | +Gets the size of /@page@/ at the current scale and rotation. +-} +pageGetSize :: + (B.CallStack.HasCallStack, MonadIO m, IsPage a) => + a + {- ^ /@page@/: A 'GI.Poppler.Objects.Page.Page' -} + -> m ((Double, Double)) +pageGetSize page = liftIO $ do + page' <- unsafeManagedPtrCastPtr page + width <- allocMem :: IO (Ptr CDouble) + height <- allocMem :: IO (Ptr CDouble) + poppler_page_get_size page' width height + width' <- peek width + let width'' = realToFrac width' + height' <- peek height + let height'' = realToFrac height' + touchManagedPtr page + freeMem width + freeMem height + return (width'', height'') + +#if ENABLE_OVERLOADING +data PageGetSizeMethodInfo +instance (signature ~ (m ((Double, Double))), MonadIO m, IsPage a) => O.MethodInfo PageGetSizeMethodInfo a signature where + overloadedMethod _ = pageGetSize + +#endif + +-- method Page::get_text +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "page", argType = TInterface (Name {namespace = "Poppler", name = "Page"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerPage", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_page_get_text" poppler_page_get_text :: + Ptr Page -> -- page : TInterface (Name {namespace = "Poppler", name = "Page"}) + IO CString + +{- | +Retrieves the text of /@page@/. + +/Since: 0.16/ +-} +pageGetText :: + (B.CallStack.HasCallStack, MonadIO m, IsPage a) => + a + {- ^ /@page@/: a 'GI.Poppler.Objects.Page.Page' -} + -> m T.Text + {- ^ __Returns:__ a pointer to the text of the /@page@/ + as a string -} +pageGetText page = liftIO $ do + page' <- unsafeManagedPtrCastPtr page + result <- poppler_page_get_text page' + checkUnexpectedReturnNULL "pageGetText" result + result' <- cstringToText result + freeMem result + touchManagedPtr page + return result' + +#if ENABLE_OVERLOADING +data PageGetTextMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsPage a) => O.MethodInfo PageGetTextMethodInfo a signature where + overloadedMethod _ = pageGetText + +#endif + +-- method Page::get_text_attributes +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "page", argType = TInterface (Name {namespace = "Poppler", name = "Page"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerPage", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TGList (TInterface (Name {namespace = "Poppler", name = "TextAttributes"}))) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_page_get_text_attributes" poppler_page_get_text_attributes :: + Ptr Page -> -- page : TInterface (Name {namespace = "Poppler", name = "Page"}) + IO (Ptr (GList (Ptr Poppler.TextAttributes.TextAttributes))) + +{- | +Obtains the attributes of the text as a 'GI.GLib.Structs.List.List' of 'GI.Poppler.Structs.TextAttributes.TextAttributes'. +This list must be freed with 'GI.Poppler.Objects.Page.pageFreeTextAttributes' when done. + +Each list element is a 'GI.Poppler.Structs.TextAttributes.TextAttributes' struct where start_index and +end_index indicates the range of text (as returned by 'GI.Poppler.Objects.Page.pageGetText') +to which text attributes apply. + +See also 'GI.Poppler.Objects.Page.pageGetTextAttributesForArea' + +/Since: 0.18/ +-} +pageGetTextAttributes :: + (B.CallStack.HasCallStack, MonadIO m, IsPage a) => + a + {- ^ /@page@/: A 'GI.Poppler.Objects.Page.Page' -} + -> m [Poppler.TextAttributes.TextAttributes] + {- ^ __Returns:__ A 'GI.GLib.Structs.List.List' of 'GI.Poppler.Structs.TextAttributes.TextAttributes' -} +pageGetTextAttributes page = liftIO $ do + page' <- unsafeManagedPtrCastPtr page + result <- poppler_page_get_text_attributes page' + result' <- unpackGList result + result'' <- mapM (wrapBoxed Poppler.TextAttributes.TextAttributes) result' + g_list_free result + touchManagedPtr page + return result'' + +#if ENABLE_OVERLOADING +data PageGetTextAttributesMethodInfo +instance (signature ~ (m [Poppler.TextAttributes.TextAttributes]), MonadIO m, IsPage a) => O.MethodInfo PageGetTextAttributesMethodInfo a signature where + overloadedMethod _ = pageGetTextAttributes + +#endif + +-- method Page::get_text_attributes_for_area +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "page", argType = TInterface (Name {namespace = "Poppler", name = "Page"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerPage", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "area", argType = TInterface (Name {namespace = "Poppler", name = "Rectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerRectangle", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TGList (TInterface (Name {namespace = "Poppler", name = "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 -> -- page : TInterface (Name {namespace = "Poppler", name = "Page"}) + Ptr Poppler.Rectangle.Rectangle -> -- area : TInterface (Name {namespace = "Poppler", name = "Rectangle"}) + IO (Ptr (GList (Ptr Poppler.TextAttributes.TextAttributes))) + +{- | +Obtains the attributes of the text in /@area@/ as a 'GI.GLib.Structs.List.List' of 'GI.Poppler.Structs.TextAttributes.TextAttributes'. +This list must be freed with 'GI.Poppler.Objects.Page.pageFreeTextAttributes' when done. + +Each list element is a 'GI.Poppler.Structs.TextAttributes.TextAttributes' struct where start_index and +end_index indicates the range of text (as returned by 'GI.Poppler.Objects.Page.pageGetTextForArea') +to which text attributes apply. + +/Since: 0.26/ +-} +pageGetTextAttributesForArea :: + (B.CallStack.HasCallStack, MonadIO m, IsPage a) => + a + {- ^ /@page@/: A 'GI.Poppler.Objects.Page.Page' -} + -> Poppler.Rectangle.Rectangle + {- ^ /@area@/: a 'GI.Poppler.Structs.Rectangle.Rectangle' -} + -> m [Poppler.TextAttributes.TextAttributes] + {- ^ __Returns:__ A 'GI.GLib.Structs.List.List' of 'GI.Poppler.Structs.TextAttributes.TextAttributes' -} +pageGetTextAttributesForArea page area = liftIO $ do + page' <- unsafeManagedPtrCastPtr page + area' <- unsafeManagedPtrGetPtr area + result <- poppler_page_get_text_attributes_for_area page' area' + result' <- unpackGList result + result'' <- mapM (wrapBoxed Poppler.TextAttributes.TextAttributes) result' + g_list_free result + touchManagedPtr page + touchManagedPtr area + return result'' + +#if ENABLE_OVERLOADING +data PageGetTextAttributesForAreaMethodInfo +instance (signature ~ (Poppler.Rectangle.Rectangle -> m [Poppler.TextAttributes.TextAttributes]), MonadIO m, IsPage a) => O.MethodInfo PageGetTextAttributesForAreaMethodInfo a signature where + overloadedMethod _ = pageGetTextAttributesForArea + +#endif + +-- method Page::get_text_for_area +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "page", argType = TInterface (Name {namespace = "Poppler", name = "Page"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerPage", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "area", argType = TInterface (Name {namespace = "Poppler", name = "Rectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerRectangle", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_page_get_text_for_area" poppler_page_get_text_for_area :: + Ptr Page -> -- page : TInterface (Name {namespace = "Poppler", name = "Page"}) + Ptr Poppler.Rectangle.Rectangle -> -- area : TInterface (Name {namespace = "Poppler", name = "Rectangle"}) + IO CString + +{- | +Retrieves the text of /@page@/ contained in /@area@/. + +/Since: 0.26/ +-} +pageGetTextForArea :: + (B.CallStack.HasCallStack, MonadIO m, IsPage a) => + a + {- ^ /@page@/: a 'GI.Poppler.Objects.Page.Page' -} + -> Poppler.Rectangle.Rectangle + {- ^ /@area@/: a 'GI.Poppler.Structs.Rectangle.Rectangle' -} + -> m T.Text + {- ^ __Returns:__ a pointer to the text as a string -} +pageGetTextForArea page area = liftIO $ do + page' <- unsafeManagedPtrCastPtr page + area' <- unsafeManagedPtrGetPtr area + result <- poppler_page_get_text_for_area page' area' + checkUnexpectedReturnNULL "pageGetTextForArea" result + result' <- cstringToText result + freeMem result + touchManagedPtr page + touchManagedPtr area + return result' + +#if ENABLE_OVERLOADING +data PageGetTextForAreaMethodInfo +instance (signature ~ (Poppler.Rectangle.Rectangle -> m T.Text), MonadIO m, IsPage a) => O.MethodInfo PageGetTextForAreaMethodInfo a signature where + overloadedMethod _ = pageGetTextForArea + +#endif + +-- method Page::get_text_layout +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "page", argType = TInterface (Name {namespace = "Poppler", name = "Page"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerPage", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rectangles", argType = TCArray False (-1) 2 (TInterface (Name {namespace = "Poppler", name = "Rectangle"})), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for an array of #PopplerRectangle", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferContainer},Arg {argCName = "n_rectangles", argType = TBasicType TUInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "length of returned array", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [Arg {argCName = "n_rectangles", argType = TBasicType TUInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "length of returned array", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_page_get_text_layout" poppler_page_get_text_layout :: + Ptr Page -> -- page : TInterface (Name {namespace = "Poppler", name = "Page"}) + Ptr (Ptr Poppler.Rectangle.Rectangle) -> -- rectangles : TCArray False (-1) 2 (TInterface (Name {namespace = "Poppler", name = "Rectangle"})) + Ptr Word32 -> -- n_rectangles : TBasicType TUInt + IO CInt + +{- | +Obtains the layout of the text as a list of 'GI.Poppler.Structs.Rectangle.Rectangle' +This array must be freed with 'GI.GLib.Functions.free' when done. + +The position in the array represents an offset in the text returned by +'GI.Poppler.Objects.Page.pageGetText' + +See also 'GI.Poppler.Objects.Page.pageGetTextLayoutForArea'. + +/Since: 0.16/ +-} +pageGetTextLayout :: + (B.CallStack.HasCallStack, MonadIO m, IsPage a) => + a + {- ^ /@page@/: A 'GI.Poppler.Objects.Page.Page' -} + -> m ((Bool, [Poppler.Rectangle.Rectangle])) + {- ^ __Returns:__ 'True' if the page contains text, 'False' otherwise -} +pageGetTextLayout page = liftIO $ do + page' <- unsafeManagedPtrCastPtr page + rectangles <- allocMem :: IO (Ptr (Ptr Poppler.Rectangle.Rectangle)) + nRectangles <- allocMem :: IO (Ptr Word32) + result <- poppler_page_get_text_layout page' rectangles nRectangles + nRectangles' <- peek nRectangles + let result' = (/= 0) result + rectangles' <- peek rectangles + rectangles'' <- (unpackBoxedArrayWithLength 32 nRectangles') rectangles' + rectangles''' <- mapM (newBoxed Poppler.Rectangle.Rectangle) rectangles'' + freeMem rectangles' + touchManagedPtr page + freeMem rectangles + freeMem nRectangles + return (result', rectangles''') + +#if ENABLE_OVERLOADING +data PageGetTextLayoutMethodInfo +instance (signature ~ (m ((Bool, [Poppler.Rectangle.Rectangle]))), MonadIO m, IsPage a) => O.MethodInfo PageGetTextLayoutMethodInfo a signature where + overloadedMethod _ = pageGetTextLayout + +#endif + +-- method Page::get_text_layout_for_area +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "page", argType = TInterface (Name {namespace = "Poppler", name = "Page"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerPage", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "area", argType = TInterface (Name {namespace = "Poppler", name = "Rectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerRectangle", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rectangles", argType = TCArray False (-1) 3 (TInterface (Name {namespace = "Poppler", name = "Rectangle"})), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for an array of #PopplerRectangle", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferContainer},Arg {argCName = "n_rectangles", argType = TBasicType TUInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "length of returned array", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [Arg {argCName = "n_rectangles", argType = TBasicType TUInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "length of returned array", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- returnType : Just (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 -> -- page : TInterface (Name {namespace = "Poppler", name = "Page"}) + Ptr Poppler.Rectangle.Rectangle -> -- area : TInterface (Name {namespace = "Poppler", name = "Rectangle"}) + Ptr (Ptr Poppler.Rectangle.Rectangle) -> -- rectangles : TCArray False (-1) 3 (TInterface (Name {namespace = "Poppler", name = "Rectangle"})) + Ptr Word32 -> -- n_rectangles : TBasicType TUInt + IO CInt + +{- | +Obtains the layout of the text contained in /@area@/ as a list of 'GI.Poppler.Structs.Rectangle.Rectangle' +This array must be freed with 'GI.GLib.Functions.free' when done. + +The position in the array represents an offset in the text returned by +'GI.Poppler.Objects.Page.pageGetTextForArea' + +/Since: 0.26/ +-} +pageGetTextLayoutForArea :: + (B.CallStack.HasCallStack, MonadIO m, IsPage a) => + a + {- ^ /@page@/: A 'GI.Poppler.Objects.Page.Page' -} + -> Poppler.Rectangle.Rectangle + {- ^ /@area@/: a 'GI.Poppler.Structs.Rectangle.Rectangle' -} + -> m ((Bool, [Poppler.Rectangle.Rectangle])) + {- ^ __Returns:__ 'True' if the page contains text, 'False' otherwise -} +pageGetTextLayoutForArea page area = liftIO $ do + page' <- unsafeManagedPtrCastPtr page + area' <- unsafeManagedPtrGetPtr area + rectangles <- allocMem :: IO (Ptr (Ptr Poppler.Rectangle.Rectangle)) + nRectangles <- allocMem :: IO (Ptr Word32) + result <- poppler_page_get_text_layout_for_area page' area' rectangles nRectangles + nRectangles' <- peek nRectangles + let result' = (/= 0) result + rectangles' <- peek rectangles + rectangles'' <- (unpackBoxedArrayWithLength 32 nRectangles') rectangles' + rectangles''' <- mapM (newBoxed Poppler.Rectangle.Rectangle) rectangles'' + freeMem rectangles' + touchManagedPtr page + touchManagedPtr area + freeMem rectangles + freeMem nRectangles + return (result', rectangles''') + +#if ENABLE_OVERLOADING +data PageGetTextLayoutForAreaMethodInfo +instance (signature ~ (Poppler.Rectangle.Rectangle -> m ((Bool, [Poppler.Rectangle.Rectangle]))), MonadIO m, IsPage a) => O.MethodInfo PageGetTextLayoutForAreaMethodInfo a signature where + overloadedMethod _ = pageGetTextLayoutForArea + +#endif + +-- method Page::get_thumbnail +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "page", argType = TInterface (Name {namespace = "Poppler", name = "Page"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #PopplerPage to get the thumbnail for", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "cairo", name = "Surface"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_page_get_thumbnail" poppler_page_get_thumbnail :: + Ptr Page -> -- page : TInterface (Name {namespace = "Poppler", name = "Page"}) + IO (Ptr Cairo.Surface.Surface) + +{- | +Get the embedded thumbnail for the specified page. If the document +doesn\'t have an embedded thumbnail for the page, this function +returns 'Nothing'. +-} +pageGetThumbnail :: + (B.CallStack.HasCallStack, MonadIO m, IsPage a) => + a + {- ^ /@page@/: the 'GI.Poppler.Objects.Page.Page' to get the thumbnail for -} + -> m Cairo.Surface.Surface + {- ^ __Returns:__ the tumbnail as a cairo_surface_t or 'Nothing' if the document +doesn\'t have a thumbnail for this page. -} +pageGetThumbnail page = liftIO $ do + page' <- unsafeManagedPtrCastPtr page + result <- poppler_page_get_thumbnail page' + checkUnexpectedReturnNULL "pageGetThumbnail" result + result' <- (wrapBoxed Cairo.Surface.Surface) result + touchManagedPtr page + return result' + +#if ENABLE_OVERLOADING +data PageGetThumbnailMethodInfo +instance (signature ~ (m Cairo.Surface.Surface), MonadIO m, IsPage a) => O.MethodInfo PageGetThumbnailMethodInfo a signature where + overloadedMethod _ = pageGetThumbnail + +#endif + +-- method Page::get_thumbnail_size +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "page", argType = TInterface (Name {namespace = "Poppler", name = "Page"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerPage", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for width", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "height", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for height", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_page_get_thumbnail_size" poppler_page_get_thumbnail_size :: + Ptr Page -> -- page : TInterface (Name {namespace = "Poppler", name = "Page"}) + Ptr Int32 -> -- width : TBasicType TInt + Ptr Int32 -> -- height : TBasicType TInt + IO CInt + +{- | +Returns 'True' if /@page@/ has a thumbnail associated with it. It also +fills in /@width@/ and /@height@/ with the width and height of the +thumbnail. The values of width and height are not changed if no +appropriate thumbnail exists. +-} +pageGetThumbnailSize :: + (B.CallStack.HasCallStack, MonadIO m, IsPage a) => + a + {- ^ /@page@/: A 'GI.Poppler.Objects.Page.Page' -} + -> m ((Bool, Int32, Int32)) + {- ^ __Returns:__ 'True', if /@page@/ has a thumbnail associated with it. -} +pageGetThumbnailSize page = liftIO $ do + page' <- unsafeManagedPtrCastPtr page + width <- allocMem :: IO (Ptr Int32) + height <- allocMem :: IO (Ptr Int32) + result <- poppler_page_get_thumbnail_size page' width height + let result' = (/= 0) result + width' <- peek width + height' <- peek height + touchManagedPtr page + freeMem width + freeMem height + return (result', width', height') + +#if ENABLE_OVERLOADING +data PageGetThumbnailSizeMethodInfo +instance (signature ~ (m ((Bool, Int32, Int32))), MonadIO m, IsPage a) => O.MethodInfo PageGetThumbnailSizeMethodInfo a signature where + overloadedMethod _ = pageGetThumbnailSize + +#endif + +-- method Page::get_transition +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "page", argType = TInterface (Name {namespace = "Poppler", name = "Page"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerPage", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "PageTransition"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_page_get_transition" poppler_page_get_transition :: + Ptr Page -> -- page : TInterface (Name {namespace = "Poppler", name = "Page"}) + IO (Ptr Poppler.PageTransition.PageTransition) + +{- | +Returns the transition effect of /@page@/ +-} +pageGetTransition :: + (B.CallStack.HasCallStack, MonadIO m, IsPage a) => + a + {- ^ /@page@/: a 'GI.Poppler.Objects.Page.Page' -} + -> m Poppler.PageTransition.PageTransition + {- ^ __Returns:__ a 'GI.Poppler.Structs.PageTransition.PageTransition' or 'Nothing'. -} +pageGetTransition page = liftIO $ do + page' <- unsafeManagedPtrCastPtr page + result <- poppler_page_get_transition page' + checkUnexpectedReturnNULL "pageGetTransition" result + result' <- (wrapBoxed Poppler.PageTransition.PageTransition) result + touchManagedPtr page + return result' + +#if ENABLE_OVERLOADING +data PageGetTransitionMethodInfo +instance (signature ~ (m Poppler.PageTransition.PageTransition), MonadIO m, IsPage a) => O.MethodInfo PageGetTransitionMethodInfo a signature where + overloadedMethod _ = pageGetTransition + +#endif + +-- method Page::remove_annot +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "page", argType = TInterface (Name {namespace = "Poppler", name = "Page"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerPage", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "annot", argType = TInterface (Name {namespace = "Poppler", name = "Annot"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerAnnot to remove", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_page_remove_annot" poppler_page_remove_annot :: + Ptr Page -> -- page : TInterface (Name {namespace = "Poppler", name = "Page"}) + Ptr Poppler.Annot.Annot -> -- annot : TInterface (Name {namespace = "Poppler", name = "Annot"}) + IO () + +{- | +Removes annotation /@annot@/ from /@page@/ + +/Since: 0.22/ +-} +pageRemoveAnnot :: + (B.CallStack.HasCallStack, MonadIO m, IsPage a, Poppler.Annot.IsAnnot b) => + a + {- ^ /@page@/: a 'GI.Poppler.Objects.Page.Page' -} + -> b + {- ^ /@annot@/: a 'GI.Poppler.Objects.Annot.Annot' to remove -} + -> m () +pageRemoveAnnot page annot = liftIO $ do + page' <- unsafeManagedPtrCastPtr page + annot' <- unsafeManagedPtrCastPtr annot + poppler_page_remove_annot page' annot' + touchManagedPtr page + touchManagedPtr annot + return () + +#if ENABLE_OVERLOADING +data PageRemoveAnnotMethodInfo +instance (signature ~ (b -> m ()), MonadIO m, IsPage a, Poppler.Annot.IsAnnot b) => O.MethodInfo PageRemoveAnnotMethodInfo a signature where + overloadedMethod _ = pageRemoveAnnot + +#endif + +-- method Page::render +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "page", argType = TInterface (Name {namespace = "Poppler", name = "Page"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the page to render from", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cairo", argType = TInterface (Name {namespace = "cairo", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "cairo context to render to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_page_render" poppler_page_render :: + Ptr Page -> -- page : TInterface (Name {namespace = "Poppler", name = "Page"}) + Ptr Cairo.Context.Context -> -- cairo : TInterface (Name {namespace = "cairo", name = "Context"}) + IO () + +{- | +Render the page to the given cairo context. This function +is for rendering a page that will be displayed. If you want +to render a page that will be printed use +'GI.Poppler.Objects.Page.pageRenderForPrinting' instead +-} +pageRender :: + (B.CallStack.HasCallStack, MonadIO m, IsPage a) => + a + {- ^ /@page@/: the page to render from -} + -> Cairo.Context.Context + {- ^ /@cairo@/: cairo context to render to -} + -> m () +pageRender page cairo = liftIO $ do + page' <- unsafeManagedPtrCastPtr page + cairo' <- unsafeManagedPtrGetPtr cairo + poppler_page_render page' cairo' + touchManagedPtr page + touchManagedPtr cairo + return () + +#if ENABLE_OVERLOADING +data PageRenderMethodInfo +instance (signature ~ (Cairo.Context.Context -> m ()), MonadIO m, IsPage a) => O.MethodInfo PageRenderMethodInfo a signature where + overloadedMethod _ = pageRender + +#endif + +-- method Page::render_for_printing +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "page", argType = TInterface (Name {namespace = "Poppler", name = "Page"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the page to render from", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cairo", argType = TInterface (Name {namespace = "cairo", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "cairo context to render to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_page_render_for_printing" poppler_page_render_for_printing :: + Ptr Page -> -- page : TInterface (Name {namespace = "Poppler", name = "Page"}) + Ptr Cairo.Context.Context -> -- cairo : TInterface (Name {namespace = "cairo", name = "Context"}) + IO () + +{- | +Render the page to the given cairo context for printing. +-} +pageRenderForPrinting :: + (B.CallStack.HasCallStack, MonadIO m, IsPage a) => + a + {- ^ /@page@/: the page to render from -} + -> Cairo.Context.Context + {- ^ /@cairo@/: cairo context to render to -} + -> m () +pageRenderForPrinting page cairo = liftIO $ do + page' <- unsafeManagedPtrCastPtr page + cairo' <- unsafeManagedPtrGetPtr cairo + poppler_page_render_for_printing page' cairo' + touchManagedPtr page + touchManagedPtr cairo + return () + +#if ENABLE_OVERLOADING +data PageRenderForPrintingMethodInfo +instance (signature ~ (Cairo.Context.Context -> m ()), MonadIO m, IsPage a) => O.MethodInfo PageRenderForPrintingMethodInfo a signature where + overloadedMethod _ = pageRenderForPrinting + +#endif + +-- method Page::render_for_printing_with_options +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "page", argType = TInterface (Name {namespace = "Poppler", name = "Page"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the page to render from", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cairo", argType = TInterface (Name {namespace = "cairo", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "cairo context to render to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "options", argType = TInterface (Name {namespace = "Poppler", name = "PrintFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "print options", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_page_render_for_printing_with_options" poppler_page_render_for_printing_with_options :: + Ptr Page -> -- page : TInterface (Name {namespace = "Poppler", name = "Page"}) + Ptr Cairo.Context.Context -> -- cairo : TInterface (Name {namespace = "cairo", name = "Context"}) + CUInt -> -- options : TInterface (Name {namespace = "Poppler", name = "PrintFlags"}) + IO () + +{- | +Render the page to the given cairo context for printing +with the specified options + +/Since: 0.16/ +-} +pageRenderForPrintingWithOptions :: + (B.CallStack.HasCallStack, MonadIO m, IsPage a) => + a + {- ^ /@page@/: the page to render from -} + -> Cairo.Context.Context + {- ^ /@cairo@/: cairo context to render to -} + -> [Poppler.Flags.PrintFlags] + {- ^ /@options@/: print options -} + -> m () +pageRenderForPrintingWithOptions page cairo options = liftIO $ do + page' <- unsafeManagedPtrCastPtr page + cairo' <- unsafeManagedPtrGetPtr cairo + let options' = gflagsToWord options + poppler_page_render_for_printing_with_options page' cairo' options' + touchManagedPtr page + touchManagedPtr cairo + return () + +#if ENABLE_OVERLOADING +data PageRenderForPrintingWithOptionsMethodInfo +instance (signature ~ (Cairo.Context.Context -> [Poppler.Flags.PrintFlags] -> m ()), MonadIO m, IsPage a) => O.MethodInfo PageRenderForPrintingWithOptionsMethodInfo a signature where + overloadedMethod _ = pageRenderForPrintingWithOptions + +#endif + +-- method Page::render_selection +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "page", argType = TInterface (Name {namespace = "Poppler", name = "Page"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #PopplerPage for which to render selection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cairo", argType = TInterface (Name {namespace = "cairo", name = "Context"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "cairo context to render to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "selection", argType = TInterface (Name {namespace = "Poppler", name = "Rectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "start and end point of selection as a rectangle", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "old_selection", argType = TInterface (Name {namespace = "Poppler", name = "Rectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "previous selection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "style", argType = TInterface (Name {namespace = "Poppler", name = "SelectionStyle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerSelectionStyle", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "glyph_color", argType = TInterface (Name {namespace = "Poppler", name = "Color"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "color to use for drawing glyphs", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "background_color", argType = TInterface (Name {namespace = "Poppler", name = "Color"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "color to use for the selection background", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_page_render_selection" poppler_page_render_selection :: + Ptr Page -> -- page : TInterface (Name {namespace = "Poppler", name = "Page"}) + Ptr Cairo.Context.Context -> -- cairo : TInterface (Name {namespace = "cairo", name = "Context"}) + Ptr Poppler.Rectangle.Rectangle -> -- selection : TInterface (Name {namespace = "Poppler", name = "Rectangle"}) + Ptr Poppler.Rectangle.Rectangle -> -- old_selection : TInterface (Name {namespace = "Poppler", name = "Rectangle"}) + CUInt -> -- style : TInterface (Name {namespace = "Poppler", name = "SelectionStyle"}) + Ptr Poppler.Color.Color -> -- glyph_color : TInterface (Name {namespace = "Poppler", name = "Color"}) + Ptr Poppler.Color.Color -> -- background_color : TInterface (Name {namespace = "Poppler", name = "Color"}) + IO () + +{- | +Render the selection specified by /@selection@/ for /@page@/ to +the given cairo context. The selection will be rendered, using +/@glyphColor@/ for the glyphs and /@backgroundColor@/ for the selection +background. + +If non-NULL, /@oldSelection@/ specifies the selection that is already +rendered to /@cairo@/, in which case this function will (some day) +only render the changed part of the selection. +-} +pageRenderSelection :: + (B.CallStack.HasCallStack, MonadIO m, IsPage a) => + a + {- ^ /@page@/: the 'GI.Poppler.Objects.Page.Page' for which to render selection -} + -> Cairo.Context.Context + {- ^ /@cairo@/: cairo context to render to -} + -> Poppler.Rectangle.Rectangle + {- ^ /@selection@/: start and end point of selection as a rectangle -} + -> Poppler.Rectangle.Rectangle + {- ^ /@oldSelection@/: previous selection -} + -> Poppler.Enums.SelectionStyle + {- ^ /@style@/: a 'GI.Poppler.Enums.SelectionStyle' -} + -> Poppler.Color.Color + {- ^ /@glyphColor@/: color to use for drawing glyphs -} + -> Poppler.Color.Color + {- ^ /@backgroundColor@/: color to use for the selection background -} + -> m () +pageRenderSelection page cairo selection oldSelection style glyphColor backgroundColor = liftIO $ do + page' <- unsafeManagedPtrCastPtr page + cairo' <- unsafeManagedPtrGetPtr cairo + selection' <- unsafeManagedPtrGetPtr selection + oldSelection' <- unsafeManagedPtrGetPtr oldSelection + let style' = (fromIntegral . fromEnum) style + glyphColor' <- unsafeManagedPtrGetPtr glyphColor + backgroundColor' <- unsafeManagedPtrGetPtr backgroundColor + poppler_page_render_selection page' cairo' selection' oldSelection' style' glyphColor' backgroundColor' + touchManagedPtr page + touchManagedPtr cairo + touchManagedPtr selection + touchManagedPtr oldSelection + touchManagedPtr glyphColor + touchManagedPtr backgroundColor + return () + +#if ENABLE_OVERLOADING +data PageRenderSelectionMethodInfo +instance (signature ~ (Cairo.Context.Context -> Poppler.Rectangle.Rectangle -> Poppler.Rectangle.Rectangle -> Poppler.Enums.SelectionStyle -> Poppler.Color.Color -> Poppler.Color.Color -> m ()), MonadIO m, IsPage a) => O.MethodInfo PageRenderSelectionMethodInfo a signature where + overloadedMethod _ = pageRenderSelection + +#endif + +-- method Page::render_to_ps +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "page", argType = TInterface (Name {namespace = "Poppler", name = "Page"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerPage", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ps_file", argType = TInterface (Name {namespace = "Poppler", name = "PSFile"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the PopplerPSFile to render to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_page_render_to_ps" poppler_page_render_to_ps :: + Ptr Page -> -- page : TInterface (Name {namespace = "Poppler", name = "Page"}) + Ptr Poppler.PSFile.PSFile -> -- ps_file : TInterface (Name {namespace = "Poppler", name = "PSFile"}) + IO () + +{- | +Render the page on a postscript file +-} +pageRenderToPs :: + (B.CallStack.HasCallStack, MonadIO m, IsPage a, Poppler.PSFile.IsPSFile b) => + a + {- ^ /@page@/: a 'GI.Poppler.Objects.Page.Page' -} + -> b + {- ^ /@psFile@/: the PopplerPSFile to render to -} + -> m () +pageRenderToPs page psFile = liftIO $ do + page' <- unsafeManagedPtrCastPtr page + psFile' <- unsafeManagedPtrCastPtr psFile + poppler_page_render_to_ps page' psFile' + touchManagedPtr page + touchManagedPtr psFile + return () + +#if ENABLE_OVERLOADING +data PageRenderToPsMethodInfo +instance (signature ~ (b -> m ()), MonadIO m, IsPage a, Poppler.PSFile.IsPSFile b) => O.MethodInfo PageRenderToPsMethodInfo a signature where + overloadedMethod _ = pageRenderToPs + +#endif + +-- method Page::free_annot_mapping +-- method type : MemberFunction +-- Args : [Arg {argCName = "list", argType = TGList (TInterface (Name {namespace = "Poppler", name = "AnnotMapping"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A list of\n #PopplerAnnotMappings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_page_free_annot_mapping" poppler_page_free_annot_mapping :: + Ptr (GList (Ptr Poppler.AnnotMapping.AnnotMapping)) -> -- list : TGList (TInterface (Name {namespace = "Poppler", name = "AnnotMapping"})) + IO () + +{- | +Frees a list of 'GI.Poppler.Structs.AnnotMapping.AnnotMapping'\s allocated by +'GI.Poppler.Objects.Page.pageGetAnnotMapping'. It also unreferences the 'GI.Poppler.Objects.Annot.Annot'\s +that each mapping contains, so if you want to keep them around, you need to +reference them with 'GI.GObject.Objects.Object.objectRef'. +-} +pageFreeAnnotMapping :: + (B.CallStack.HasCallStack, MonadIO m) => + [Poppler.AnnotMapping.AnnotMapping] + {- ^ /@list@/: A list of + 'GI.Poppler.Structs.AnnotMapping.AnnotMapping'\s -} + -> m () +pageFreeAnnotMapping list = liftIO $ do + list' <- mapM unsafeManagedPtrGetPtr list + list'' <- packGList list' + poppler_page_free_annot_mapping list'' + mapM_ touchManagedPtr list + g_list_free list'' + return () + +#if ENABLE_OVERLOADING +#endif + +-- method Page::free_form_field_mapping +-- method type : MemberFunction +-- Args : [Arg {argCName = "list", argType = TGList (TInterface (Name {namespace = "Poppler", name = "FormFieldMapping"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A list of\n #PopplerFormFieldMappings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_page_free_form_field_mapping" poppler_page_free_form_field_mapping :: + Ptr (GList (Ptr Poppler.FormFieldMapping.FormFieldMapping)) -> -- list : TGList (TInterface (Name {namespace = "Poppler", name = "FormFieldMapping"})) + IO () + +{- | +Frees a list of 'GI.Poppler.Structs.FormFieldMapping.FormFieldMapping'\s allocated by +'GI.Poppler.Objects.Page.pageGetFormFieldMapping'. +-} +pageFreeFormFieldMapping :: + (B.CallStack.HasCallStack, MonadIO m) => + [Poppler.FormFieldMapping.FormFieldMapping] + {- ^ /@list@/: A list of + 'GI.Poppler.Structs.FormFieldMapping.FormFieldMapping'\s -} + -> m () +pageFreeFormFieldMapping list = liftIO $ do + list' <- mapM unsafeManagedPtrGetPtr list + list'' <- packGList list' + poppler_page_free_form_field_mapping list'' + mapM_ touchManagedPtr list + g_list_free list'' + return () + +#if ENABLE_OVERLOADING +#endif + +-- method Page::free_image_mapping +-- method type : MemberFunction +-- Args : [Arg {argCName = "list", argType = TGList (TInterface (Name {namespace = "Poppler", name = "ImageMapping"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A list of\n #PopplerImageMappings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_page_free_image_mapping" poppler_page_free_image_mapping :: + Ptr (GList (Ptr Poppler.ImageMapping.ImageMapping)) -> -- list : TGList (TInterface (Name {namespace = "Poppler", name = "ImageMapping"})) + IO () + +{- | +Frees a list of 'GI.Poppler.Structs.ImageMapping.ImageMapping'\s allocated by +'GI.Poppler.Objects.Page.pageGetImageMapping'. +-} +pageFreeImageMapping :: + (B.CallStack.HasCallStack, MonadIO m) => + [Poppler.ImageMapping.ImageMapping] + {- ^ /@list@/: A list of + 'GI.Poppler.Structs.ImageMapping.ImageMapping'\s -} + -> m () +pageFreeImageMapping list = liftIO $ do + list' <- mapM unsafeManagedPtrGetPtr list + list'' <- packGList list' + poppler_page_free_image_mapping list'' + mapM_ touchManagedPtr list + g_list_free list'' + return () + +#if ENABLE_OVERLOADING +#endif + +-- method Page::free_link_mapping +-- method type : MemberFunction +-- Args : [Arg {argCName = "list", argType = TGList (TInterface (Name {namespace = "Poppler", name = "LinkMapping"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A list of\n #PopplerLinkMappings", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_page_free_link_mapping" poppler_page_free_link_mapping :: + Ptr (GList (Ptr Poppler.LinkMapping.LinkMapping)) -> -- list : TGList (TInterface (Name {namespace = "Poppler", name = "LinkMapping"})) + IO () + +{- | +Frees a list of 'GI.Poppler.Structs.LinkMapping.LinkMapping'\s allocated by +'GI.Poppler.Objects.Page.pageGetLinkMapping'. It also frees the 'GI.Poppler.Unions.Action.Action'\s +that each mapping contains, so if you want to keep them around, you need to +copy them with 'GI.Poppler.Unions.Action.actionCopy'. +-} +pageFreeLinkMapping :: + (B.CallStack.HasCallStack, MonadIO m) => + [Poppler.LinkMapping.LinkMapping] + {- ^ /@list@/: A list of + 'GI.Poppler.Structs.LinkMapping.LinkMapping'\s -} + -> m () +pageFreeLinkMapping list = liftIO $ do + list' <- mapM unsafeManagedPtrGetPtr list + list'' <- packGList list' + poppler_page_free_link_mapping list'' + mapM_ touchManagedPtr list + g_list_free list'' + return () + +#if ENABLE_OVERLOADING +#endif + +-- method Page::free_text_attributes +-- method type : MemberFunction +-- Args : [Arg {argCName = "list", argType = TGList (TInterface (Name {namespace = "Poppler", name = "TextAttributes"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A list of\n #PopplerTextAttributess", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_page_free_text_attributes" poppler_page_free_text_attributes :: + Ptr (GList (Ptr Poppler.TextAttributes.TextAttributes)) -> -- list : TGList (TInterface (Name {namespace = "Poppler", name = "TextAttributes"})) + IO () + +{- | +Frees a list of 'GI.Poppler.Structs.TextAttributes.TextAttributes'\s allocated by +'GI.Poppler.Objects.Page.pageGetTextAttributes'. + +/Since: 0.18/ +-} +pageFreeTextAttributes :: + (B.CallStack.HasCallStack, MonadIO m) => + [Poppler.TextAttributes.TextAttributes] + {- ^ /@list@/: A list of + 'GI.Poppler.Structs.TextAttributes.TextAttributes'\s -} + -> m () +pageFreeTextAttributes list = liftIO $ do + list' <- mapM unsafeManagedPtrGetPtr list + list'' <- packGList list' + poppler_page_free_text_attributes list'' + mapM_ touchManagedPtr list + g_list_free list'' + return () + +#if ENABLE_OVERLOADING +#endif + +-- method Page::selection_region_free +-- method type : MemberFunction +-- Args : [Arg {argCName = "region", argType = TGList (TInterface (Name {namespace = "Poppler", name = "Rectangle"})), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GList of\n #PopplerRectangle", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_page_selection_region_free" poppler_page_selection_region_free :: + Ptr (GList (Ptr Poppler.Rectangle.Rectangle)) -> -- region : TGList (TInterface (Name {namespace = "Poppler", name = "Rectangle"})) + IO () + +{-# DEPRECATED pageSelectionRegionFree ["(Since version 0.16)"] #-} +{- | +Frees /@region@/ +-} +pageSelectionRegionFree :: + (B.CallStack.HasCallStack, MonadIO m) => + [Poppler.Rectangle.Rectangle] + {- ^ /@region@/: a 'GI.GLib.Structs.List.List' of + 'GI.Poppler.Structs.Rectangle.Rectangle' -} + -> m () +pageSelectionRegionFree region = liftIO $ do + region' <- mapM unsafeManagedPtrGetPtr region + region'' <- packGList region' + poppler_page_selection_region_free region'' + mapM_ touchManagedPtr region + g_list_free region'' + return () + +#if ENABLE_OVERLOADING +#endif + + 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,125 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Poppler.Objects.Page where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype Page = Page (ManagedPtr Page) +instance GObject Page where +class (GObject o, O.IsDescendantOf Page o) => IsPage o +instance (GObject o, O.IsDescendantOf Page o) => IsPage o +instance O.HasParentTypes Page +#if ENABLE_OVERLOADING +data PageLabelPropertyInfo +#endif +#if ENABLE_OVERLOADING +data PageAddAnnotMethodInfo +#endif +#if ENABLE_OVERLOADING +data PageFindTextMethodInfo +#endif +#if ENABLE_OVERLOADING +data PageFindTextWithOptionsMethodInfo +#endif +#if ENABLE_OVERLOADING +data PageGetAnnotMappingMethodInfo +#endif +#if ENABLE_OVERLOADING +data PageGetCropBoxMethodInfo +#endif +#if ENABLE_OVERLOADING +data PageGetDurationMethodInfo +#endif +#if ENABLE_OVERLOADING +data PageGetFormFieldMappingMethodInfo +#endif +#if ENABLE_OVERLOADING +data PageGetImageMethodInfo +#endif +#if ENABLE_OVERLOADING +data PageGetImageMappingMethodInfo +#endif +#if ENABLE_OVERLOADING +data PageGetIndexMethodInfo +#endif +#if ENABLE_OVERLOADING +data PageGetLabelMethodInfo +#endif +#if ENABLE_OVERLOADING +data PageGetLinkMappingMethodInfo +#endif +#if ENABLE_OVERLOADING +data PageGetSelectedRegionMethodInfo +#endif +#if ENABLE_OVERLOADING +data PageGetSelectedTextMethodInfo +#endif +#if ENABLE_OVERLOADING +data PageGetSelectionRegionMethodInfo +#endif +#if ENABLE_OVERLOADING +data PageGetSizeMethodInfo +#endif +#if ENABLE_OVERLOADING +data PageGetTextMethodInfo +#endif +#if ENABLE_OVERLOADING +data PageGetTextAttributesMethodInfo +#endif +#if ENABLE_OVERLOADING +data PageGetTextAttributesForAreaMethodInfo +#endif +#if ENABLE_OVERLOADING +data PageGetTextForAreaMethodInfo +#endif +#if ENABLE_OVERLOADING +data PageGetTextLayoutMethodInfo +#endif +#if ENABLE_OVERLOADING +data PageGetTextLayoutForAreaMethodInfo +#endif +#if ENABLE_OVERLOADING +data PageGetThumbnailMethodInfo +#endif +#if ENABLE_OVERLOADING +data PageGetThumbnailSizeMethodInfo +#endif +#if ENABLE_OVERLOADING +data PageGetTransitionMethodInfo +#endif +#if ENABLE_OVERLOADING +data PageRemoveAnnotMethodInfo +#endif +#if ENABLE_OVERLOADING +data PageRenderMethodInfo +#endif +#if ENABLE_OVERLOADING +data PageRenderForPrintingMethodInfo +#endif +#if ENABLE_OVERLOADING +data PageRenderForPrintingWithOptionsMethodInfo +#endif +#if ENABLE_OVERLOADING +data PageRenderSelectionMethodInfo +#endif +#if ENABLE_OVERLOADING +data PageRenderToPsMethodInfo +#endif 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,2827 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Poppler.Objects.StructureElement + ( +#if ENABLE_OVERLOADING + StructureElementGetBorderColorMethodInfo, +#endif + +-- * Exported types + StructureElement(..) , + IsStructureElement , + toStructureElement , + noStructureElement , + + + -- * Methods +-- ** getAbbreviation #method:getAbbreviation# + +#if ENABLE_OVERLOADING + StructureElementGetAbbreviationMethodInfo, +#endif + structureElementGetAbbreviation , + + +-- ** getActualText #method:getActualText# + +#if ENABLE_OVERLOADING + StructureElementGetActualTextMethodInfo , +#endif + structureElementGetActualText , + + +-- ** getAltText #method:getAltText# + +#if ENABLE_OVERLOADING + StructureElementGetAltTextMethodInfo , +#endif + structureElementGetAltText , + + +-- ** getBackgroundColor #method:getBackgroundColor# + +#if ENABLE_OVERLOADING + StructureElementGetBackgroundColorMethodInfo, +#endif + structureElementGetBackgroundColor , + + +-- ** getBaselineShift #method:getBaselineShift# + +#if ENABLE_OVERLOADING + StructureElementGetBaselineShiftMethodInfo, +#endif + structureElementGetBaselineShift , + + +-- ** getBlockAlign #method:getBlockAlign# + +#if ENABLE_OVERLOADING + StructureElementGetBlockAlignMethodInfo , +#endif + structureElementGetBlockAlign , + + +-- ** getBorderStyle #method:getBorderStyle# + +#if ENABLE_OVERLOADING + StructureElementGetBorderStyleMethodInfo, +#endif + structureElementGetBorderStyle , + + +-- ** getBorderThickness #method:getBorderThickness# + +#if ENABLE_OVERLOADING + StructureElementGetBorderThicknessMethodInfo, +#endif + structureElementGetBorderThickness , + + +-- ** getBoundingBox #method:getBoundingBox# + +#if ENABLE_OVERLOADING + StructureElementGetBoundingBoxMethodInfo, +#endif + structureElementGetBoundingBox , + + +-- ** getColor #method:getColor# + +#if ENABLE_OVERLOADING + StructureElementGetColorMethodInfo , +#endif + structureElementGetColor , + + +-- ** getColumnCount #method:getColumnCount# + +#if ENABLE_OVERLOADING + StructureElementGetColumnCountMethodInfo, +#endif + structureElementGetColumnCount , + + +-- ** getColumnGaps #method:getColumnGaps# + +#if ENABLE_OVERLOADING + StructureElementGetColumnGapsMethodInfo , +#endif + structureElementGetColumnGaps , + + +-- ** getColumnWidths #method:getColumnWidths# + +#if ENABLE_OVERLOADING + StructureElementGetColumnWidthsMethodInfo, +#endif + structureElementGetColumnWidths , + + +-- ** getEndIndent #method:getEndIndent# + +#if ENABLE_OVERLOADING + StructureElementGetEndIndentMethodInfo , +#endif + structureElementGetEndIndent , + + +-- ** getFormDescription #method:getFormDescription# + +#if ENABLE_OVERLOADING + StructureElementGetFormDescriptionMethodInfo, +#endif + structureElementGetFormDescription , + + +-- ** getFormRole #method:getFormRole# + +#if ENABLE_OVERLOADING + StructureElementGetFormRoleMethodInfo , +#endif + structureElementGetFormRole , + + +-- ** getFormState #method:getFormState# + +#if ENABLE_OVERLOADING + StructureElementGetFormStateMethodInfo , +#endif + structureElementGetFormState , + + +-- ** getGlyphOrientation #method:getGlyphOrientation# + +#if ENABLE_OVERLOADING + StructureElementGetGlyphOrientationMethodInfo, +#endif + structureElementGetGlyphOrientation , + + +-- ** getHeight #method:getHeight# + +#if ENABLE_OVERLOADING + StructureElementGetHeightMethodInfo , +#endif + structureElementGetHeight , + + +-- ** getId #method:getId# + +#if ENABLE_OVERLOADING + StructureElementGetIdMethodInfo , +#endif + structureElementGetId , + + +-- ** getInlineAlign #method:getInlineAlign# + +#if ENABLE_OVERLOADING + StructureElementGetInlineAlignMethodInfo, +#endif + structureElementGetInlineAlign , + + +-- ** getKind #method:getKind# + +#if ENABLE_OVERLOADING + StructureElementGetKindMethodInfo , +#endif + structureElementGetKind , + + +-- ** getLanguage #method:getLanguage# + +#if ENABLE_OVERLOADING + StructureElementGetLanguageMethodInfo , +#endif + structureElementGetLanguage , + + +-- ** getLineHeight #method:getLineHeight# + +#if ENABLE_OVERLOADING + StructureElementGetLineHeightMethodInfo , +#endif + structureElementGetLineHeight , + + +-- ** getListNumbering #method:getListNumbering# + +#if ENABLE_OVERLOADING + StructureElementGetListNumberingMethodInfo, +#endif + structureElementGetListNumbering , + + +-- ** getPadding #method:getPadding# + +#if ENABLE_OVERLOADING + StructureElementGetPaddingMethodInfo , +#endif + structureElementGetPadding , + + +-- ** getPage #method:getPage# + +#if ENABLE_OVERLOADING + StructureElementGetPageMethodInfo , +#endif + structureElementGetPage , + + +-- ** getPlacement #method:getPlacement# + +#if ENABLE_OVERLOADING + StructureElementGetPlacementMethodInfo , +#endif + structureElementGetPlacement , + + +-- ** getRubyAlign #method:getRubyAlign# + +#if ENABLE_OVERLOADING + StructureElementGetRubyAlignMethodInfo , +#endif + structureElementGetRubyAlign , + + +-- ** getRubyPosition #method:getRubyPosition# + +#if ENABLE_OVERLOADING + StructureElementGetRubyPositionMethodInfo, +#endif + structureElementGetRubyPosition , + + +-- ** getSpaceAfter #method:getSpaceAfter# + +#if ENABLE_OVERLOADING + StructureElementGetSpaceAfterMethodInfo , +#endif + structureElementGetSpaceAfter , + + +-- ** getSpaceBefore #method:getSpaceBefore# + +#if ENABLE_OVERLOADING + StructureElementGetSpaceBeforeMethodInfo, +#endif + structureElementGetSpaceBefore , + + +-- ** getStartIndent #method:getStartIndent# + +#if ENABLE_OVERLOADING + StructureElementGetStartIndentMethodInfo, +#endif + structureElementGetStartIndent , + + +-- ** getTableBorderStyle #method:getTableBorderStyle# + +#if ENABLE_OVERLOADING + StructureElementGetTableBorderStyleMethodInfo, +#endif + structureElementGetTableBorderStyle , + + +-- ** getTableColumnSpan #method:getTableColumnSpan# + +#if ENABLE_OVERLOADING + StructureElementGetTableColumnSpanMethodInfo, +#endif + structureElementGetTableColumnSpan , + + +-- ** getTableHeaders #method:getTableHeaders# + +#if ENABLE_OVERLOADING + StructureElementGetTableHeadersMethodInfo, +#endif + structureElementGetTableHeaders , + + +-- ** getTablePadding #method:getTablePadding# + +#if ENABLE_OVERLOADING + StructureElementGetTablePaddingMethodInfo, +#endif + structureElementGetTablePadding , + + +-- ** getTableRowSpan #method:getTableRowSpan# + +#if ENABLE_OVERLOADING + StructureElementGetTableRowSpanMethodInfo, +#endif + structureElementGetTableRowSpan , + + +-- ** getTableScope #method:getTableScope# + +#if ENABLE_OVERLOADING + StructureElementGetTableScopeMethodInfo , +#endif + structureElementGetTableScope , + + +-- ** getTableSummary #method:getTableSummary# + +#if ENABLE_OVERLOADING + StructureElementGetTableSummaryMethodInfo, +#endif + structureElementGetTableSummary , + + +-- ** getText #method:getText# + +#if ENABLE_OVERLOADING + StructureElementGetTextMethodInfo , +#endif + structureElementGetText , + + +-- ** getTextAlign #method:getTextAlign# + +#if ENABLE_OVERLOADING + StructureElementGetTextAlignMethodInfo , +#endif + structureElementGetTextAlign , + + +-- ** getTextDecorationColor #method:getTextDecorationColor# + +#if ENABLE_OVERLOADING + StructureElementGetTextDecorationColorMethodInfo, +#endif + structureElementGetTextDecorationColor , + + +-- ** getTextDecorationThickness #method:getTextDecorationThickness# + +#if ENABLE_OVERLOADING + StructureElementGetTextDecorationThicknessMethodInfo, +#endif + structureElementGetTextDecorationThickness, + + +-- ** getTextDecorationType #method:getTextDecorationType# + +#if ENABLE_OVERLOADING + StructureElementGetTextDecorationTypeMethodInfo, +#endif + structureElementGetTextDecorationType , + + +-- ** getTextIndent #method:getTextIndent# + +#if ENABLE_OVERLOADING + StructureElementGetTextIndentMethodInfo , +#endif + structureElementGetTextIndent , + + +-- ** getTextSpans #method:getTextSpans# + +#if ENABLE_OVERLOADING + StructureElementGetTextSpansMethodInfo , +#endif + structureElementGetTextSpans , + + +-- ** getTitle #method:getTitle# + +#if ENABLE_OVERLOADING + StructureElementGetTitleMethodInfo , +#endif + structureElementGetTitle , + + +-- ** getWidth #method:getWidth# + +#if ENABLE_OVERLOADING + StructureElementGetWidthMethodInfo , +#endif + structureElementGetWidth , + + +-- ** getWritingMode #method:getWritingMode# + +#if ENABLE_OVERLOADING + StructureElementGetWritingModeMethodInfo, +#endif + structureElementGetWritingMode , + + +-- ** isBlock #method:isBlock# + +#if ENABLE_OVERLOADING + StructureElementIsBlockMethodInfo , +#endif + structureElementIsBlock , + + +-- ** isContent #method:isContent# + +#if ENABLE_OVERLOADING + StructureElementIsContentMethodInfo , +#endif + structureElementIsContent , + + +-- ** isGrouping #method:isGrouping# + +#if ENABLE_OVERLOADING + StructureElementIsGroupingMethodInfo , +#endif + structureElementIsGrouping , + + +-- ** isInline #method:isInline# + +#if ENABLE_OVERLOADING + StructureElementIsInlineMethodInfo , +#endif + structureElementIsInline , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import qualified GI.GObject.Objects.Object as GObject.Object +import {-# SOURCE #-} qualified GI.Poppler.Enums as Poppler.Enums +import {-# SOURCE #-} qualified GI.Poppler.Flags as Poppler.Flags +import {-# SOURCE #-} qualified GI.Poppler.Structs.Color as Poppler.Color +import {-# SOURCE #-} qualified GI.Poppler.Structs.Rectangle as Poppler.Rectangle +import {-# SOURCE #-} qualified GI.Poppler.Structs.TextSpan as Poppler.TextSpan + +-- | Memory-managed wrapper type. +newtype StructureElement = StructureElement (ManagedPtr StructureElement) +foreign import ccall "poppler_structure_element_get_type" + c_poppler_structure_element_get_type :: IO GType + +instance GObject StructureElement where + gobjectType = c_poppler_structure_element_get_type + + +-- | Type class for types which can be safely cast to `StructureElement`, for instance with `toStructureElement`. +class (GObject o, O.IsDescendantOf StructureElement o) => IsStructureElement o +instance (GObject o, O.IsDescendantOf StructureElement o) => IsStructureElement o + +instance O.HasParentTypes StructureElement +type instance O.ParentTypes StructureElement = '[GObject.Object.Object] + +-- | Cast to `StructureElement`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toStructureElement :: (MonadIO m, IsStructureElement o) => o -> m StructureElement +toStructureElement = liftIO . unsafeCastTo StructureElement + +-- | A convenience alias for `Nothing` :: `Maybe` `StructureElement`. +noStructureElement :: Maybe StructureElement +noStructureElement = Nothing + +#if ENABLE_OVERLOADING +type family ResolveStructureElementMethod (t :: Symbol) (o :: *) :: * where + ResolveStructureElementMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveStructureElementMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveStructureElementMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveStructureElementMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveStructureElementMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveStructureElementMethod "isBlock" o = StructureElementIsBlockMethodInfo + ResolveStructureElementMethod "isContent" o = StructureElementIsContentMethodInfo + ResolveStructureElementMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveStructureElementMethod "isGrouping" o = StructureElementIsGroupingMethodInfo + ResolveStructureElementMethod "isInline" o = StructureElementIsInlineMethodInfo + ResolveStructureElementMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveStructureElementMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveStructureElementMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveStructureElementMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveStructureElementMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveStructureElementMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveStructureElementMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveStructureElementMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveStructureElementMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveStructureElementMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveStructureElementMethod "getAbbreviation" o = StructureElementGetAbbreviationMethodInfo + ResolveStructureElementMethod "getActualText" o = StructureElementGetActualTextMethodInfo + ResolveStructureElementMethod "getAltText" o = StructureElementGetAltTextMethodInfo + ResolveStructureElementMethod "getBackgroundColor" o = StructureElementGetBackgroundColorMethodInfo + ResolveStructureElementMethod "getBaselineShift" o = StructureElementGetBaselineShiftMethodInfo + ResolveStructureElementMethod "getBlockAlign" o = StructureElementGetBlockAlignMethodInfo + ResolveStructureElementMethod "getBorderColor" o = StructureElementGetBorderColorMethodInfo + ResolveStructureElementMethod "getBorderStyle" o = StructureElementGetBorderStyleMethodInfo + ResolveStructureElementMethod "getBorderThickness" o = StructureElementGetBorderThicknessMethodInfo + ResolveStructureElementMethod "getBoundingBox" o = StructureElementGetBoundingBoxMethodInfo + ResolveStructureElementMethod "getColor" o = StructureElementGetColorMethodInfo + ResolveStructureElementMethod "getColumnCount" o = StructureElementGetColumnCountMethodInfo + ResolveStructureElementMethod "getColumnGaps" o = StructureElementGetColumnGapsMethodInfo + ResolveStructureElementMethod "getColumnWidths" o = StructureElementGetColumnWidthsMethodInfo + ResolveStructureElementMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveStructureElementMethod "getEndIndent" o = StructureElementGetEndIndentMethodInfo + ResolveStructureElementMethod "getFormDescription" o = StructureElementGetFormDescriptionMethodInfo + ResolveStructureElementMethod "getFormRole" o = StructureElementGetFormRoleMethodInfo + ResolveStructureElementMethod "getFormState" o = StructureElementGetFormStateMethodInfo + ResolveStructureElementMethod "getGlyphOrientation" o = StructureElementGetGlyphOrientationMethodInfo + ResolveStructureElementMethod "getHeight" o = StructureElementGetHeightMethodInfo + ResolveStructureElementMethod "getId" o = StructureElementGetIdMethodInfo + ResolveStructureElementMethod "getInlineAlign" o = StructureElementGetInlineAlignMethodInfo + ResolveStructureElementMethod "getKind" o = StructureElementGetKindMethodInfo + ResolveStructureElementMethod "getLanguage" o = StructureElementGetLanguageMethodInfo + ResolveStructureElementMethod "getLineHeight" o = StructureElementGetLineHeightMethodInfo + ResolveStructureElementMethod "getListNumbering" o = StructureElementGetListNumberingMethodInfo + ResolveStructureElementMethod "getPadding" o = StructureElementGetPaddingMethodInfo + ResolveStructureElementMethod "getPage" o = StructureElementGetPageMethodInfo + ResolveStructureElementMethod "getPlacement" o = StructureElementGetPlacementMethodInfo + ResolveStructureElementMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveStructureElementMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveStructureElementMethod "getRubyAlign" o = StructureElementGetRubyAlignMethodInfo + ResolveStructureElementMethod "getRubyPosition" o = StructureElementGetRubyPositionMethodInfo + ResolveStructureElementMethod "getSpaceAfter" o = StructureElementGetSpaceAfterMethodInfo + ResolveStructureElementMethod "getSpaceBefore" o = StructureElementGetSpaceBeforeMethodInfo + ResolveStructureElementMethod "getStartIndent" o = StructureElementGetStartIndentMethodInfo + ResolveStructureElementMethod "getTableBorderStyle" o = StructureElementGetTableBorderStyleMethodInfo + ResolveStructureElementMethod "getTableColumnSpan" o = StructureElementGetTableColumnSpanMethodInfo + ResolveStructureElementMethod "getTableHeaders" o = StructureElementGetTableHeadersMethodInfo + ResolveStructureElementMethod "getTablePadding" o = StructureElementGetTablePaddingMethodInfo + ResolveStructureElementMethod "getTableRowSpan" o = StructureElementGetTableRowSpanMethodInfo + ResolveStructureElementMethod "getTableScope" o = StructureElementGetTableScopeMethodInfo + ResolveStructureElementMethod "getTableSummary" o = StructureElementGetTableSummaryMethodInfo + ResolveStructureElementMethod "getText" o = StructureElementGetTextMethodInfo + ResolveStructureElementMethod "getTextAlign" o = StructureElementGetTextAlignMethodInfo + ResolveStructureElementMethod "getTextDecorationColor" o = StructureElementGetTextDecorationColorMethodInfo + ResolveStructureElementMethod "getTextDecorationThickness" o = StructureElementGetTextDecorationThicknessMethodInfo + ResolveStructureElementMethod "getTextDecorationType" o = StructureElementGetTextDecorationTypeMethodInfo + ResolveStructureElementMethod "getTextIndent" o = StructureElementGetTextIndentMethodInfo + ResolveStructureElementMethod "getTextSpans" o = StructureElementGetTextSpansMethodInfo + ResolveStructureElementMethod "getTitle" o = StructureElementGetTitleMethodInfo + ResolveStructureElementMethod "getWidth" o = StructureElementGetWidthMethodInfo + ResolveStructureElementMethod "getWritingMode" o = StructureElementGetWritingModeMethodInfo + ResolveStructureElementMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveStructureElementMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveStructureElementMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveStructureElementMethod t StructureElement, O.MethodInfo info StructureElement p) => OL.IsLabel t (StructureElement -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList StructureElement +type instance O.AttributeList StructureElement = StructureElementAttributeList +type StructureElementAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList StructureElement = StructureElementSignalList +type StructureElementSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method StructureElement::get_abbreviation +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_structure_element", argType = TInterface (Name {namespace = "Poppler", name = "StructureElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerStructureElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_structure_element_get_abbreviation" poppler_structure_element_get_abbreviation :: + Ptr StructureElement -> -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"}) + IO CString + +{- | +Acronyms and abbreviations contained in elements of type +@/POPPLER_STRUCTURE_ELEMENT_SPAN/@ may have an associated expanded +text form, which can be retrieved using this function. + +/Since: 0.26/ +-} +structureElementGetAbbreviation :: + (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) => + a + {- ^ /@popplerStructureElement@/: A 'GI.Poppler.Objects.StructureElement.StructureElement' -} + -> m T.Text + {- ^ __Returns:__ Text of the expanded abbreviation if the + element text is an abbreviation or acrony, 'Nothing' if not. -} +structureElementGetAbbreviation popplerStructureElement = liftIO $ do + popplerStructureElement' <- unsafeManagedPtrCastPtr popplerStructureElement + result <- poppler_structure_element_get_abbreviation popplerStructureElement' + checkUnexpectedReturnNULL "structureElementGetAbbreviation" result + result' <- cstringToText result + freeMem result + touchManagedPtr popplerStructureElement + return result' + +#if ENABLE_OVERLOADING +data StructureElementGetAbbreviationMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsStructureElement a) => O.MethodInfo StructureElementGetAbbreviationMethodInfo a signature where + overloadedMethod _ = structureElementGetAbbreviation + +#endif + +-- method StructureElement::get_actual_text +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_structure_element", argType = TInterface (Name {namespace = "Poppler", name = "StructureElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerStructureElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_structure_element_get_actual_text" poppler_structure_element_get_actual_text :: + Ptr StructureElement -> -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"}) + IO CString + +{- | +Obtains the actual text enclosed by the element (and its child elements). +The actual text is mostly used for non-text elements like images and +figures which \do\<\/emphasis> have the graphical appearance of text, like +a logo. For those the actual text is the equivalent text to those +graphical elements which look like text when rendered. + +Note that for elements containing proper text, the function +'GI.Poppler.Objects.StructureElement.structureElementGetText' must be used instead. + +/Since: 0.26/ +-} +structureElementGetActualText :: + (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) => + a + {- ^ /@popplerStructureElement@/: A 'GI.Poppler.Objects.StructureElement.StructureElement' -} + -> m T.Text + {- ^ __Returns:__ The actual text for the element, or 'Nothing' + if not defined. -} +structureElementGetActualText popplerStructureElement = liftIO $ do + popplerStructureElement' <- unsafeManagedPtrCastPtr popplerStructureElement + result <- poppler_structure_element_get_actual_text popplerStructureElement' + checkUnexpectedReturnNULL "structureElementGetActualText" result + result' <- cstringToText result + freeMem result + touchManagedPtr popplerStructureElement + return result' + +#if ENABLE_OVERLOADING +data StructureElementGetActualTextMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsStructureElement a) => O.MethodInfo StructureElementGetActualTextMethodInfo a signature where + overloadedMethod _ = structureElementGetActualText + +#endif + +-- method StructureElement::get_alt_text +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_structure_element", argType = TInterface (Name {namespace = "Poppler", name = "StructureElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerStructureElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_structure_element_get_alt_text" poppler_structure_element_get_alt_text :: + Ptr StructureElement -> -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"}) + IO CString + +{- | +Obtains the “alternate” text representation of the element (and its child +elements). This is mostly used for non-text elements like images and +figures, to specify a textual description of the element. + +Note that for elements containing proper text, the function +'GI.Poppler.Objects.StructureElement.structureElementGetText' must be used instead. + +/Since: 0.26/ +-} +structureElementGetAltText :: + (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) => + a + {- ^ /@popplerStructureElement@/: A 'GI.Poppler.Objects.StructureElement.StructureElement' -} + -> m T.Text + {- ^ __Returns:__ The alternate text representation for the + element, or 'Nothing' if not defined. -} +structureElementGetAltText popplerStructureElement = liftIO $ do + popplerStructureElement' <- unsafeManagedPtrCastPtr popplerStructureElement + result <- poppler_structure_element_get_alt_text popplerStructureElement' + checkUnexpectedReturnNULL "structureElementGetAltText" result + result' <- cstringToText result + freeMem result + touchManagedPtr popplerStructureElement + return result' + +#if ENABLE_OVERLOADING +data StructureElementGetAltTextMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsStructureElement a) => O.MethodInfo StructureElementGetAltTextMethodInfo a signature where + overloadedMethod _ = structureElementGetAltText + +#endif + +-- method StructureElement::get_background_color +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_structure_element", argType = TInterface (Name {namespace = "Poppler", name = "StructureElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerStructureElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "color", argType = TInterface (Name {namespace = "Poppler", name = "Color"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerColor.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_structure_element_get_background_color" poppler_structure_element_get_background_color :: + Ptr StructureElement -> -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"}) + Ptr Poppler.Color.Color -> -- color : TInterface (Name {namespace = "Poppler", name = "Color"}) + IO CInt + +{- | +Obtains the background color of the element. If this attribute is +not specified, the element shall be treated as if it were transparent. + +/Since: 0.26/ +-} +structureElementGetBackgroundColor :: + (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) => + a + {- ^ /@popplerStructureElement@/: A 'GI.Poppler.Objects.StructureElement.StructureElement' -} + -> m ((Bool, Poppler.Color.Color)) + {- ^ __Returns:__ 'True' if a color is defined for the element, + 'False' otherwise. -} +structureElementGetBackgroundColor popplerStructureElement = liftIO $ do + popplerStructureElement' <- unsafeManagedPtrCastPtr popplerStructureElement + color <- callocBoxedBytes 6 :: IO (Ptr Poppler.Color.Color) + result <- poppler_structure_element_get_background_color popplerStructureElement' color + let result' = (/= 0) result + color' <- (wrapBoxed Poppler.Color.Color) color + touchManagedPtr popplerStructureElement + return (result', color') + +#if ENABLE_OVERLOADING +data StructureElementGetBackgroundColorMethodInfo +instance (signature ~ (m ((Bool, Poppler.Color.Color))), MonadIO m, IsStructureElement a) => O.MethodInfo StructureElementGetBackgroundColorMethodInfo a signature where + overloadedMethod _ = structureElementGetBackgroundColor + +#endif + +-- method StructureElement::get_baseline_shift +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_structure_element", argType = TInterface (Name {namespace = "Poppler", name = "StructureElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerStructureElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TDouble) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_structure_element_get_baseline_shift" poppler_structure_element_get_baseline_shift :: + Ptr StructureElement -> -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"}) + IO CDouble + +{- | +Obtains how much the text contained in the inline-level structure element should be shifted, +measuring from the baseline of the glyphs. + +/Since: 0.26/ +-} +structureElementGetBaselineShift :: + (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) => + a + {- ^ /@popplerStructureElement@/: A 'GI.Poppler.Objects.StructureElement.StructureElement' -} + -> m Double + {- ^ __Returns:__ A numeric value. -} +structureElementGetBaselineShift popplerStructureElement = liftIO $ do + popplerStructureElement' <- unsafeManagedPtrCastPtr popplerStructureElement + result <- poppler_structure_element_get_baseline_shift popplerStructureElement' + let result' = realToFrac result + touchManagedPtr popplerStructureElement + return result' + +#if ENABLE_OVERLOADING +data StructureElementGetBaselineShiftMethodInfo +instance (signature ~ (m Double), MonadIO m, IsStructureElement a) => O.MethodInfo StructureElementGetBaselineShiftMethodInfo a signature where + overloadedMethod _ = structureElementGetBaselineShift + +#endif + +-- method StructureElement::get_block_align +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_structure_element", argType = TInterface (Name {namespace = "Poppler", name = "StructureElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerStructureElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "StructureBlockAlign"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_structure_element_get_block_align" poppler_structure_element_get_block_align :: + Ptr StructureElement -> -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"}) + IO CUInt + +{- | +Obtains the block-alignment mode of the block-level structure element. + +/Since: 0.26/ +-} +structureElementGetBlockAlign :: + (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) => + a + {- ^ /@popplerStructureElement@/: A 'GI.Poppler.Objects.StructureElement.StructureElement' -} + -> m Poppler.Enums.StructureBlockAlign + {- ^ __Returns:__ A 'GI.Poppler.Enums.StructureBlockAlign' value. -} +structureElementGetBlockAlign popplerStructureElement = liftIO $ do + popplerStructureElement' <- unsafeManagedPtrCastPtr popplerStructureElement + result <- poppler_structure_element_get_block_align popplerStructureElement' + let result' = (toEnum . fromIntegral) result + touchManagedPtr popplerStructureElement + return result' + +#if ENABLE_OVERLOADING +data StructureElementGetBlockAlignMethodInfo +instance (signature ~ (m Poppler.Enums.StructureBlockAlign), MonadIO m, IsStructureElement a) => O.MethodInfo StructureElementGetBlockAlignMethodInfo a signature where + overloadedMethod _ = structureElementGetBlockAlign + +#endif + +-- XXX Could not generate method StructureElement::get_border_color +-- Error was : Not implemented: "Don't know how to allocate \"colors\" of type TCArray False 4 (-1) (TInterface (Name {namespace = \"Poppler\", name = \"Color\"}))" +#if ENABLE_OVERLOADING +-- XXX: Dummy instance, since code generation failed. +-- Please file a bug at http://github.com/haskell-gi/haskell-gi. +data StructureElementGetBorderColorMethodInfo +instance (p ~ (), o ~ O.MethodResolutionFailed "getBorderColor" StructureElement) => O.MethodInfo StructureElementGetBorderColorMethodInfo o p where + overloadedMethod _ = undefined +#endif + +-- method StructureElement::get_border_style +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_structure_element", argType = TInterface (Name {namespace = "Poppler", name = "StructureElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerStructureElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "border_styles", argType = TCArray False 4 (-1) (TInterface (Name {namespace = "Poppler", name = "StructureBorderStyle"})), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "\n An array of four #PopplerStructureBorderStyle elements.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_structure_element_get_border_style" poppler_structure_element_get_border_style :: + Ptr StructureElement -> -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"}) + Ptr (Ptr CUInt) -> -- border_styles : TCArray False 4 (-1) (TInterface (Name {namespace = "Poppler", name = "StructureBorderStyle"})) + IO () + +{- | +Obtains the border style of a structure element. The result values +are in before-after-start-end ordering. For example, using Western +left-to-right writing, that is top-bottom-left-right. + +/Since: 0.26/ +-} +structureElementGetBorderStyle :: + (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) => + a + {- ^ /@popplerStructureElement@/: A 'GI.Poppler.Objects.StructureElement.StructureElement' -} + -> m ([Poppler.Enums.StructureBorderStyle]) +structureElementGetBorderStyle popplerStructureElement = liftIO $ do + popplerStructureElement' <- unsafeManagedPtrCastPtr popplerStructureElement + borderStyles <- allocMem :: IO (Ptr (Ptr CUInt)) + poppler_structure_element_get_border_style popplerStructureElement' borderStyles + borderStyles' <- peek borderStyles + borderStyles'' <- (unpackStorableArrayWithLength 4) borderStyles' + let borderStyles''' = map (toEnum . fromIntegral) borderStyles'' + freeMem borderStyles' + touchManagedPtr popplerStructureElement + freeMem borderStyles + return borderStyles''' + +#if ENABLE_OVERLOADING +data StructureElementGetBorderStyleMethodInfo +instance (signature ~ (m ([Poppler.Enums.StructureBorderStyle])), MonadIO m, IsStructureElement a) => O.MethodInfo StructureElementGetBorderStyleMethodInfo a signature where + overloadedMethod _ = structureElementGetBorderStyle + +#endif + +-- method StructureElement::get_border_thickness +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_structure_element", argType = TInterface (Name {namespace = "Poppler", name = "StructureElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerStructureElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "border_thicknesses", argType = TCArray False 4 (-1) (TBasicType TDouble), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "\n Array with the four values of border thicknesses.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_structure_element_get_border_thickness" poppler_structure_element_get_border_thickness :: + Ptr StructureElement -> -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"}) + Ptr (Ptr CDouble) -> -- border_thicknesses : TCArray False 4 (-1) (TBasicType TDouble) + IO CInt + +{- | +Obtains the thickness of the border of an element. The result values +are in before-after-start-end ordering (for the typical Western +left-to-right writing, that is top-bottom-left-right). +A value of 0 indicates that the border shall not be drawn. + +/Since: 0.26/ +-} +structureElementGetBorderThickness :: + (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) => + a + {- ^ /@popplerStructureElement@/: A 'GI.Poppler.Objects.StructureElement.StructureElement' -} + -> m ((Bool, [Double])) + {- ^ __Returns:__ 'True' if the border thickness attribute is defined for + the element, 'False' otherwise. -} +structureElementGetBorderThickness popplerStructureElement = liftIO $ do + popplerStructureElement' <- unsafeManagedPtrCastPtr popplerStructureElement + borderThicknesses <- allocMem :: IO (Ptr (Ptr CDouble)) + result <- poppler_structure_element_get_border_thickness popplerStructureElement' borderThicknesses + let result' = (/= 0) result + borderThicknesses' <- peek borderThicknesses + borderThicknesses'' <- (unpackMapStorableArrayWithLength realToFrac 4) borderThicknesses' + freeMem borderThicknesses' + touchManagedPtr popplerStructureElement + freeMem borderThicknesses + return (result', borderThicknesses'') + +#if ENABLE_OVERLOADING +data StructureElementGetBorderThicknessMethodInfo +instance (signature ~ (m ((Bool, [Double]))), MonadIO m, IsStructureElement a) => O.MethodInfo StructureElementGetBorderThicknessMethodInfo a signature where + overloadedMethod _ = structureElementGetBorderThickness + +#endif + +-- method StructureElement::get_bounding_box +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_structure_element", argType = TInterface (Name {namespace = "Poppler", name = "StructureElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerStructureElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "bounding_box", argType = TInterface (Name {namespace = "Poppler", name = "Rectangle"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerRectangle.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_structure_element_get_bounding_box" poppler_structure_element_get_bounding_box :: + Ptr StructureElement -> -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"}) + Ptr Poppler.Rectangle.Rectangle -> -- bounding_box : TInterface (Name {namespace = "Poppler", name = "Rectangle"}) + IO CInt + +{- | +Obtains the size of the bounding box of a block-level structure element. + +/Since: 0.26/ +-} +structureElementGetBoundingBox :: + (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) => + a + {- ^ /@popplerStructureElement@/: A 'GI.Poppler.Objects.StructureElement.StructureElement' -} + -> m ((Bool, Poppler.Rectangle.Rectangle)) + {- ^ __Returns:__ 'True' if a bounding box is defined for the element, + 'False' otherwise. -} +structureElementGetBoundingBox popplerStructureElement = liftIO $ do + popplerStructureElement' <- unsafeManagedPtrCastPtr popplerStructureElement + boundingBox <- callocBoxedBytes 32 :: IO (Ptr Poppler.Rectangle.Rectangle) + result <- poppler_structure_element_get_bounding_box popplerStructureElement' boundingBox + let result' = (/= 0) result + boundingBox' <- (wrapBoxed Poppler.Rectangle.Rectangle) boundingBox + touchManagedPtr popplerStructureElement + return (result', boundingBox') + +#if ENABLE_OVERLOADING +data StructureElementGetBoundingBoxMethodInfo +instance (signature ~ (m ((Bool, Poppler.Rectangle.Rectangle))), MonadIO m, IsStructureElement a) => O.MethodInfo StructureElementGetBoundingBoxMethodInfo a signature where + overloadedMethod _ = structureElementGetBoundingBox + +#endif + +-- method StructureElement::get_color +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_structure_element", argType = TInterface (Name {namespace = "Poppler", name = "StructureElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerStructureElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "color", argType = TInterface (Name {namespace = "Poppler", name = "Color"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerColor.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_structure_element_get_color" poppler_structure_element_get_color :: + Ptr StructureElement -> -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"}) + Ptr Poppler.Color.Color -> -- color : TInterface (Name {namespace = "Poppler", name = "Color"}) + IO CInt + +{- | +Obtains the color of the content contained in the element. +If this attribute is not specified, the color for this element shall +be the current text fill color in effect at the start of its associated content. + +/Since: 0.26/ +-} +structureElementGetColor :: + (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) => + a + {- ^ /@popplerStructureElement@/: A 'GI.Poppler.Objects.StructureElement.StructureElement' -} + -> m ((Bool, Poppler.Color.Color)) + {- ^ __Returns:__ 'True' if a color is defined for the element, + 'False' otherwise. -} +structureElementGetColor popplerStructureElement = liftIO $ do + popplerStructureElement' <- unsafeManagedPtrCastPtr popplerStructureElement + color <- callocBoxedBytes 6 :: IO (Ptr Poppler.Color.Color) + result <- poppler_structure_element_get_color popplerStructureElement' color + let result' = (/= 0) result + color' <- (wrapBoxed Poppler.Color.Color) color + touchManagedPtr popplerStructureElement + return (result', color') + +#if ENABLE_OVERLOADING +data StructureElementGetColorMethodInfo +instance (signature ~ (m ((Bool, Poppler.Color.Color))), MonadIO m, IsStructureElement a) => O.MethodInfo StructureElementGetColorMethodInfo a signature where + overloadedMethod _ = structureElementGetColor + +#endif + +-- method StructureElement::get_column_count +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_structure_element", argType = TInterface (Name {namespace = "Poppler", name = "StructureElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerStructureElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_structure_element_get_column_count" poppler_structure_element_get_column_count :: + Ptr StructureElement -> -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"}) + IO Word32 + +{- | +Obtains the number of columns used to lay out the content contained +in the grouping element. + +/Since: 0.26/ +-} +structureElementGetColumnCount :: + (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) => + a + {- ^ /@popplerStructureElement@/: A 'GI.Poppler.Objects.StructureElement.StructureElement' -} + -> m Word32 + {- ^ __Returns:__ Number of columns. -} +structureElementGetColumnCount popplerStructureElement = liftIO $ do + popplerStructureElement' <- unsafeManagedPtrCastPtr popplerStructureElement + result <- poppler_structure_element_get_column_count popplerStructureElement' + touchManagedPtr popplerStructureElement + return result + +#if ENABLE_OVERLOADING +data StructureElementGetColumnCountMethodInfo +instance (signature ~ (m Word32), MonadIO m, IsStructureElement a) => O.MethodInfo StructureElementGetColumnCountMethodInfo a signature where + overloadedMethod _ = structureElementGetColumnCount + +#endif + +-- method StructureElement::get_column_gaps +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_structure_element", argType = TInterface (Name {namespace = "Poppler", name = "StructureElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerStructureElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_values", argType = TBasicType TUInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Size of the returned array.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [Arg {argCName = "n_values", argType = TBasicType TUInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Size of the returned array.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- returnType : Just (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 -> -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"}) + Ptr Word32 -> -- n_values : TBasicType TUInt + IO (Ptr CDouble) + +{- | +Obtains the size of the gaps in between adjacent columns. Returns an +array of elements: the first one is the size of the gap in between +columns 1 and 2, second is the size between columns 2 and 3, and so on. + +For elements which use a single column, 'Nothing' is returned and /@nValues@/ +is set to zero. + +If the attribute is undefined, 'Nothing' is returned and /@nValues@/ is set +to a non-zero value. + +The array with the results is allocated by the function. When it is +not needed anymore, be sure to call 'GI.GLib.Functions.free' on it. + +/Since: 0.26/ +-} +structureElementGetColumnGaps :: + (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) => + a + {- ^ /@popplerStructureElement@/: A 'GI.Poppler.Objects.StructureElement.StructureElement' -} + -> m [Double] + {- ^ __Returns:__ + Array containing the values for the column gaps, or 'Nothing' if the + array is empty or the attribute is not defined. -} +structureElementGetColumnGaps popplerStructureElement = liftIO $ do + popplerStructureElement' <- unsafeManagedPtrCastPtr popplerStructureElement + nValues <- allocMem :: IO (Ptr Word32) + result <- poppler_structure_element_get_column_gaps popplerStructureElement' nValues + nValues' <- peek nValues + checkUnexpectedReturnNULL "structureElementGetColumnGaps" result + result' <- (unpackMapStorableArrayWithLength realToFrac nValues') result + freeMem result + touchManagedPtr popplerStructureElement + freeMem nValues + return result' + +#if ENABLE_OVERLOADING +data StructureElementGetColumnGapsMethodInfo +instance (signature ~ (m [Double]), MonadIO m, IsStructureElement a) => O.MethodInfo StructureElementGetColumnGapsMethodInfo a signature where + overloadedMethod _ = structureElementGetColumnGaps + +#endif + +-- method StructureElement::get_column_widths +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_structure_element", argType = TInterface (Name {namespace = "Poppler", name = "StructureElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerStructureElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_values", argType = TBasicType TUInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Size of the returned array.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [Arg {argCName = "n_values", argType = TBasicType TUInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Size of the returned array.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- returnType : Just (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 -> -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"}) + Ptr Word32 -> -- n_values : TBasicType TUInt + IO (Ptr CDouble) + +{- | +Obtains an array with the widths of the columns. + +The array with the results is allocated by the function. When it is +not needed anymore, be sure to call 'GI.GLib.Functions.free' on it. + +/Since: 0.26/ +-} +structureElementGetColumnWidths :: + (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) => + a + {- ^ /@popplerStructureElement@/: A 'GI.Poppler.Objects.StructureElement.StructureElement' -} + -> m [Double] + {- ^ __Returns:__ + Array containing widths of the columns, or 'Nothing' if the attribute + is not defined. -} +structureElementGetColumnWidths popplerStructureElement = liftIO $ do + popplerStructureElement' <- unsafeManagedPtrCastPtr popplerStructureElement + nValues <- allocMem :: IO (Ptr Word32) + result <- poppler_structure_element_get_column_widths popplerStructureElement' nValues + nValues' <- peek nValues + checkUnexpectedReturnNULL "structureElementGetColumnWidths" result + result' <- (unpackMapStorableArrayWithLength realToFrac nValues') result + freeMem result + touchManagedPtr popplerStructureElement + freeMem nValues + return result' + +#if ENABLE_OVERLOADING +data StructureElementGetColumnWidthsMethodInfo +instance (signature ~ (m [Double]), MonadIO m, IsStructureElement a) => O.MethodInfo StructureElementGetColumnWidthsMethodInfo a signature where + overloadedMethod _ = structureElementGetColumnWidths + +#endif + +-- method StructureElement::get_end_indent +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_structure_element", argType = TInterface (Name {namespace = "Poppler", name = "StructureElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerStructureElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TDouble) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_structure_element_get_end_indent" poppler_structure_element_get_end_indent :: + Ptr StructureElement -> -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"}) + IO CDouble + +{- | +Obtains the amount of indentation at the end of the block-level structure element. + +/Since: 0.26/ +-} +structureElementGetEndIndent :: + (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) => + a + {- ^ /@popplerStructureElement@/: A 'GI.Poppler.Objects.StructureElement.StructureElement' -} + -> m Double + {- ^ __Returns:__ A numeric value. -} +structureElementGetEndIndent popplerStructureElement = liftIO $ do + popplerStructureElement' <- unsafeManagedPtrCastPtr popplerStructureElement + result <- poppler_structure_element_get_end_indent popplerStructureElement' + let result' = realToFrac result + touchManagedPtr popplerStructureElement + return result' + +#if ENABLE_OVERLOADING +data StructureElementGetEndIndentMethodInfo +instance (signature ~ (m Double), MonadIO m, IsStructureElement a) => O.MethodInfo StructureElementGetEndIndentMethodInfo a signature where + overloadedMethod _ = structureElementGetEndIndent + +#endif + +-- method StructureElement::get_form_description +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_structure_element", argType = TInterface (Name {namespace = "Poppler", name = "StructureElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerStructureElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_structure_element_get_form_description" poppler_structure_element_get_form_description :: + Ptr StructureElement -> -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"}) + IO CString + +{- | +Obtains the textual description of the form element. Note that the +description is for informative purposes, and it is not intended +to be rendered. For example, assistive technologies may use the +description field to provide an alternate way of presenting an +element to the user. + +The returned string is allocated by the function. When it is +not needed anymore, be sure to call 'GI.GLib.Functions.free' on it. + +/Since: 0.26/ +-} +structureElementGetFormDescription :: + (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) => + a + {- ^ /@popplerStructureElement@/: A 'GI.Poppler.Objects.StructureElement.StructureElement' -} + -> m T.Text + {- ^ __Returns:__ A string, or 'Nothing' if the attribute + is not defined. -} +structureElementGetFormDescription popplerStructureElement = liftIO $ do + popplerStructureElement' <- unsafeManagedPtrCastPtr popplerStructureElement + result <- poppler_structure_element_get_form_description popplerStructureElement' + checkUnexpectedReturnNULL "structureElementGetFormDescription" result + result' <- cstringToText result + freeMem result + touchManagedPtr popplerStructureElement + return result' + +#if ENABLE_OVERLOADING +data StructureElementGetFormDescriptionMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsStructureElement a) => O.MethodInfo StructureElementGetFormDescriptionMethodInfo a signature where + overloadedMethod _ = structureElementGetFormDescription + +#endif + +-- method StructureElement::get_form_role +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_structure_element", argType = TInterface (Name {namespace = "Poppler", name = "StructureElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerStructureElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "StructureFormRole"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_structure_element_get_form_role" poppler_structure_element_get_form_role :: + Ptr StructureElement -> -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"}) + IO CUInt + +{- | +Obtains the role of a form structure element that is part of a form, or is +a form field. This hints how the control for the element is intended +to be rendered. + +/Since: 0.26/ +-} +structureElementGetFormRole :: + (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) => + a + {- ^ /@popplerStructureElement@/: A 'GI.Poppler.Objects.StructureElement.StructureElement' -} + -> m Poppler.Enums.StructureFormRole + {- ^ __Returns:__ A 'GI.Poppler.Enums.StructureFormRole' value. -} +structureElementGetFormRole popplerStructureElement = liftIO $ do + popplerStructureElement' <- unsafeManagedPtrCastPtr popplerStructureElement + result <- poppler_structure_element_get_form_role popplerStructureElement' + let result' = (toEnum . fromIntegral) result + touchManagedPtr popplerStructureElement + return result' + +#if ENABLE_OVERLOADING +data StructureElementGetFormRoleMethodInfo +instance (signature ~ (m Poppler.Enums.StructureFormRole), MonadIO m, IsStructureElement a) => O.MethodInfo StructureElementGetFormRoleMethodInfo a signature where + overloadedMethod _ = structureElementGetFormRole + +#endif + +-- method StructureElement::get_form_state +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_structure_element", argType = TInterface (Name {namespace = "Poppler", name = "StructureElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerStructureElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "StructureFormState"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_structure_element_get_form_state" poppler_structure_element_get_form_state :: + Ptr StructureElement -> -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"}) + IO CUInt + +{- | +For a structure element that is a form field, obtains in which state +the associated control is expected to be rendered. + +/Since: 0.26/ +-} +structureElementGetFormState :: + (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) => + a + {- ^ /@popplerStructureElement@/: A 'GI.Poppler.Objects.StructureElement.StructureElement' -} + -> m Poppler.Enums.StructureFormState + {- ^ __Returns:__ A 'GI.Poppler.Enums.StructureFormState' value. -} +structureElementGetFormState popplerStructureElement = liftIO $ do + popplerStructureElement' <- unsafeManagedPtrCastPtr popplerStructureElement + result <- poppler_structure_element_get_form_state popplerStructureElement' + let result' = (toEnum . fromIntegral) result + touchManagedPtr popplerStructureElement + return result' + +#if ENABLE_OVERLOADING +data StructureElementGetFormStateMethodInfo +instance (signature ~ (m Poppler.Enums.StructureFormState), MonadIO m, IsStructureElement a) => O.MethodInfo StructureElementGetFormStateMethodInfo a signature where + overloadedMethod _ = structureElementGetFormState + +#endif + +-- method StructureElement::get_glyph_orientation +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_structure_element", argType = TInterface (Name {namespace = "Poppler", name = "StructureElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerStructureElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "StructureGlyphOrientation"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_structure_element_get_glyph_orientation" poppler_structure_element_get_glyph_orientation :: + Ptr StructureElement -> -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"}) + IO CUInt + +{- | +Obtains the glyph orientation for the text contained in a +inline-level structure element. + +/Since: 0.26/ +-} +structureElementGetGlyphOrientation :: + (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) => + a + {- ^ /@popplerStructureElement@/: A 'GI.Poppler.Objects.StructureElement.StructureElement' -} + -> m Poppler.Enums.StructureGlyphOrientation + {- ^ __Returns:__ A 'GI.Poppler.Enums.StructureGlyphOrientation' value. -} +structureElementGetGlyphOrientation popplerStructureElement = liftIO $ do + popplerStructureElement' <- unsafeManagedPtrCastPtr popplerStructureElement + result <- poppler_structure_element_get_glyph_orientation popplerStructureElement' + let result' = (toEnum . fromIntegral) result + touchManagedPtr popplerStructureElement + return result' + +#if ENABLE_OVERLOADING +data StructureElementGetGlyphOrientationMethodInfo +instance (signature ~ (m Poppler.Enums.StructureGlyphOrientation), MonadIO m, IsStructureElement a) => O.MethodInfo StructureElementGetGlyphOrientationMethodInfo a signature where + overloadedMethod _ = structureElementGetGlyphOrientation + +#endif + +-- method StructureElement::get_height +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_structure_element", argType = TInterface (Name {namespace = "Poppler", name = "StructureElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerStructureElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TDouble) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_structure_element_get_height" poppler_structure_element_get_height :: + Ptr StructureElement -> -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"}) + IO CDouble + +{- | +Obtains the height of the block-level structure element. Note that for elements which do +not specify a height, it has to be calculated, and in this case -1 is returned. + +/Since: 0.26/ +-} +structureElementGetHeight :: + (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) => + a + {- ^ /@popplerStructureElement@/: A 'GI.Poppler.Objects.StructureElement.StructureElement' -} + -> m Double + {- ^ __Returns:__ A positive value if a width is defined, or -1 + if the height is to be calculated automatically. -} +structureElementGetHeight popplerStructureElement = liftIO $ do + popplerStructureElement' <- unsafeManagedPtrCastPtr popplerStructureElement + result <- poppler_structure_element_get_height popplerStructureElement' + let result' = realToFrac result + touchManagedPtr popplerStructureElement + return result' + +#if ENABLE_OVERLOADING +data StructureElementGetHeightMethodInfo +instance (signature ~ (m Double), MonadIO m, IsStructureElement a) => O.MethodInfo StructureElementGetHeightMethodInfo a signature where + overloadedMethod _ = structureElementGetHeight + +#endif + +-- method StructureElement::get_id +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_structure_element", argType = TInterface (Name {namespace = "Poppler", name = "StructureElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerStructureElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_structure_element_get_id" poppler_structure_element_get_id :: + Ptr StructureElement -> -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"}) + IO CString + +{- | +Obtains the identifier of an element. + +/Since: 0.26/ +-} +structureElementGetId :: + (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) => + a + {- ^ /@popplerStructureElement@/: A 'GI.Poppler.Objects.StructureElement.StructureElement' -} + -> m T.Text + {- ^ __Returns:__ The identifier of the element (if + defined), or 'Nothing'. -} +structureElementGetId popplerStructureElement = liftIO $ do + popplerStructureElement' <- unsafeManagedPtrCastPtr popplerStructureElement + result <- poppler_structure_element_get_id popplerStructureElement' + checkUnexpectedReturnNULL "structureElementGetId" result + result' <- cstringToText result + freeMem result + touchManagedPtr popplerStructureElement + return result' + +#if ENABLE_OVERLOADING +data StructureElementGetIdMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsStructureElement a) => O.MethodInfo StructureElementGetIdMethodInfo a signature where + overloadedMethod _ = structureElementGetId + +#endif + +-- method StructureElement::get_inline_align +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_structure_element", argType = TInterface (Name {namespace = "Poppler", name = "StructureElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerStructureElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "StructureInlineAlign"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_structure_element_get_inline_align" poppler_structure_element_get_inline_align :: + Ptr StructureElement -> -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"}) + IO CUInt + +{- | +Obtains the inline-alignment mode of the block-level structure element. + +/Since: 0.26/ +-} +structureElementGetInlineAlign :: + (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) => + a + {- ^ /@popplerStructureElement@/: A 'GI.Poppler.Objects.StructureElement.StructureElement' -} + -> m Poppler.Enums.StructureInlineAlign + {- ^ __Returns:__ A 'GI.Poppler.Enums.StructureInlineAlign' value. -} +structureElementGetInlineAlign popplerStructureElement = liftIO $ do + popplerStructureElement' <- unsafeManagedPtrCastPtr popplerStructureElement + result <- poppler_structure_element_get_inline_align popplerStructureElement' + let result' = (toEnum . fromIntegral) result + touchManagedPtr popplerStructureElement + return result' + +#if ENABLE_OVERLOADING +data StructureElementGetInlineAlignMethodInfo +instance (signature ~ (m Poppler.Enums.StructureInlineAlign), MonadIO m, IsStructureElement a) => O.MethodInfo StructureElementGetInlineAlignMethodInfo a signature where + overloadedMethod _ = structureElementGetInlineAlign + +#endif + +-- method StructureElement::get_kind +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_structure_element", argType = TInterface (Name {namespace = "Poppler", name = "StructureElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerStructureElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "StructureElementKind"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_structure_element_get_kind" poppler_structure_element_get_kind :: + Ptr StructureElement -> -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"}) + IO CUInt + +{- | +/No description available in the introspection data./ + +/Since: 0.26/ +-} +structureElementGetKind :: + (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) => + a + {- ^ /@popplerStructureElement@/: A 'GI.Poppler.Objects.StructureElement.StructureElement' -} + -> m Poppler.Enums.StructureElementKind + {- ^ __Returns:__ A 'GI.Poppler.Enums.StructureElementKind' value. -} +structureElementGetKind popplerStructureElement = liftIO $ do + popplerStructureElement' <- unsafeManagedPtrCastPtr popplerStructureElement + result <- poppler_structure_element_get_kind popplerStructureElement' + let result' = (toEnum . fromIntegral) result + touchManagedPtr popplerStructureElement + return result' + +#if ENABLE_OVERLOADING +data StructureElementGetKindMethodInfo +instance (signature ~ (m Poppler.Enums.StructureElementKind), MonadIO m, IsStructureElement a) => O.MethodInfo StructureElementGetKindMethodInfo a signature where + overloadedMethod _ = structureElementGetKind + +#endif + +-- method StructureElement::get_language +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_structure_element", argType = TInterface (Name {namespace = "Poppler", name = "StructureElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerStructureElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_structure_element_get_language" poppler_structure_element_get_language :: + Ptr StructureElement -> -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"}) + IO CString + +{- | +Obtains the language and country code for the content in an element, +in two-letter ISO format, e.g. \en_ES\<\/code>, or 'Nothing' if not +defined. + +/Since: 0.26/ +-} +structureElementGetLanguage :: + (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) => + a + {- ^ /@popplerStructureElement@/: A 'GI.Poppler.Objects.StructureElement.StructureElement' -} + -> m T.Text + {- ^ __Returns:__ language and country code, or 'Nothing'. -} +structureElementGetLanguage popplerStructureElement = liftIO $ do + popplerStructureElement' <- unsafeManagedPtrCastPtr popplerStructureElement + result <- poppler_structure_element_get_language popplerStructureElement' + checkUnexpectedReturnNULL "structureElementGetLanguage" result + result' <- cstringToText result + freeMem result + touchManagedPtr popplerStructureElement + return result' + +#if ENABLE_OVERLOADING +data StructureElementGetLanguageMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsStructureElement a) => O.MethodInfo StructureElementGetLanguageMethodInfo a signature where + overloadedMethod _ = structureElementGetLanguage + +#endif + +-- method StructureElement::get_line_height +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_structure_element", argType = TInterface (Name {namespace = "Poppler", name = "StructureElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerStructureElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TDouble) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_structure_element_get_line_height" poppler_structure_element_get_line_height :: + Ptr StructureElement -> -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"}) + IO CDouble + +{- | +Obtains the line height for the text contained in the inline-level structure element. +Note that for elements which do not specify a line height, it has to be calculated, +and in this case -1 is returned. + +/Since: 0.26/ +-} +structureElementGetLineHeight :: + (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) => + a + {- ^ /@popplerStructureElement@/: A 'GI.Poppler.Objects.StructureElement.StructureElement' -} + -> m Double + {- ^ __Returns:__ A positive value if a line height is defined, or -1 + if the height is to be calculated automatically. -} +structureElementGetLineHeight popplerStructureElement = liftIO $ do + popplerStructureElement' <- unsafeManagedPtrCastPtr popplerStructureElement + result <- poppler_structure_element_get_line_height popplerStructureElement' + let result' = realToFrac result + touchManagedPtr popplerStructureElement + return result' + +#if ENABLE_OVERLOADING +data StructureElementGetLineHeightMethodInfo +instance (signature ~ (m Double), MonadIO m, IsStructureElement a) => O.MethodInfo StructureElementGetLineHeightMethodInfo a signature where + overloadedMethod _ = structureElementGetLineHeight + +#endif + +-- method StructureElement::get_list_numbering +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_structure_element", argType = TInterface (Name {namespace = "Poppler", name = "StructureElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerStructureElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "StructureListNumbering"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_structure_element_get_list_numbering" poppler_structure_element_get_list_numbering :: + Ptr StructureElement -> -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"}) + IO CUInt + +{- | +Obtains the list numbering style for list items. + +/Since: 0.26/ +-} +structureElementGetListNumbering :: + (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) => + a + {- ^ /@popplerStructureElement@/: A 'GI.Poppler.Objects.StructureElement.StructureElement' -} + -> m Poppler.Enums.StructureListNumbering + {- ^ __Returns:__ A 'GI.Poppler.Enums.StructureListNumbering' value. -} +structureElementGetListNumbering popplerStructureElement = liftIO $ do + popplerStructureElement' <- unsafeManagedPtrCastPtr popplerStructureElement + result <- poppler_structure_element_get_list_numbering popplerStructureElement' + let result' = (toEnum . fromIntegral) result + touchManagedPtr popplerStructureElement + return result' + +#if ENABLE_OVERLOADING +data StructureElementGetListNumberingMethodInfo +instance (signature ~ (m Poppler.Enums.StructureListNumbering), MonadIO m, IsStructureElement a) => O.MethodInfo StructureElementGetListNumberingMethodInfo a signature where + overloadedMethod _ = structureElementGetListNumbering + +#endif + +-- method StructureElement::get_padding +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_structure_element", argType = TInterface (Name {namespace = "Poppler", name = "StructureElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerStructureElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "paddings", argType = TCArray False 4 (-1) (TBasicType TDouble), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "\n Padding for the four sides of the element.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_structure_element_get_padding" poppler_structure_element_get_padding :: + Ptr StructureElement -> -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"}) + Ptr (Ptr CDouble) -> -- paddings : TCArray False 4 (-1) (TBasicType TDouble) + IO () + +{- | +Obtains the padding of an element (space around it). The result +values are in before-after-start-end ordering. For example using +Western left-to-right writing, that is top-bottom-left-right. + +/Since: 0.26/ +-} +structureElementGetPadding :: + (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) => + a + {- ^ /@popplerStructureElement@/: A 'GI.Poppler.Objects.StructureElement.StructureElement' -} + -> m ([Double]) +structureElementGetPadding popplerStructureElement = liftIO $ do + popplerStructureElement' <- unsafeManagedPtrCastPtr popplerStructureElement + paddings <- allocMem :: IO (Ptr (Ptr CDouble)) + poppler_structure_element_get_padding popplerStructureElement' paddings + paddings' <- peek paddings + paddings'' <- (unpackMapStorableArrayWithLength realToFrac 4) paddings' + freeMem paddings' + touchManagedPtr popplerStructureElement + freeMem paddings + return paddings'' + +#if ENABLE_OVERLOADING +data StructureElementGetPaddingMethodInfo +instance (signature ~ (m ([Double])), MonadIO m, IsStructureElement a) => O.MethodInfo StructureElementGetPaddingMethodInfo a signature where + overloadedMethod _ = structureElementGetPadding + +#endif + +-- method StructureElement::get_page +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_structure_element", argType = TInterface (Name {namespace = "Poppler", name = "StructureElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerStructureElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_structure_element_get_page" poppler_structure_element_get_page :: + Ptr StructureElement -> -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"}) + IO Int32 + +{- | +Obtains the page number in which the element is contained. + +/Since: 0.26/ +-} +structureElementGetPage :: + (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) => + a + {- ^ /@popplerStructureElement@/: A 'GI.Poppler.Objects.StructureElement.StructureElement' -} + -> m Int32 + {- ^ __Returns:__ Number of the page that contains the element, of + \-1\<\/code> if not defined. -} +structureElementGetPage popplerStructureElement = liftIO $ do + popplerStructureElement' <- unsafeManagedPtrCastPtr popplerStructureElement + result <- poppler_structure_element_get_page popplerStructureElement' + touchManagedPtr popplerStructureElement + return result + +#if ENABLE_OVERLOADING +data StructureElementGetPageMethodInfo +instance (signature ~ (m Int32), MonadIO m, IsStructureElement a) => O.MethodInfo StructureElementGetPageMethodInfo a signature where + overloadedMethod _ = structureElementGetPage + +#endif + +-- method StructureElement::get_placement +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_structure_element", argType = TInterface (Name {namespace = "Poppler", name = "StructureElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerStructureElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "StructurePlacement"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_structure_element_get_placement" poppler_structure_element_get_placement :: + Ptr StructureElement -> -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"}) + IO CUInt + +{- | +Obtains the placement type of the structure element. + +/Since: 0.26/ +-} +structureElementGetPlacement :: + (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) => + a + {- ^ /@popplerStructureElement@/: A 'GI.Poppler.Objects.StructureElement.StructureElement' -} + -> m Poppler.Enums.StructurePlacement + {- ^ __Returns:__ A 'GI.Poppler.Enums.StructurePlacement' value. -} +structureElementGetPlacement popplerStructureElement = liftIO $ do + popplerStructureElement' <- unsafeManagedPtrCastPtr popplerStructureElement + result <- poppler_structure_element_get_placement popplerStructureElement' + let result' = (toEnum . fromIntegral) result + touchManagedPtr popplerStructureElement + return result' + +#if ENABLE_OVERLOADING +data StructureElementGetPlacementMethodInfo +instance (signature ~ (m Poppler.Enums.StructurePlacement), MonadIO m, IsStructureElement a) => O.MethodInfo StructureElementGetPlacementMethodInfo a signature where + overloadedMethod _ = structureElementGetPlacement + +#endif + +-- method StructureElement::get_ruby_align +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_structure_element", argType = TInterface (Name {namespace = "Poppler", name = "StructureElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerStructureElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "StructureRubyAlign"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_structure_element_get_ruby_align" poppler_structure_element_get_ruby_align :: + Ptr StructureElement -> -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"}) + IO CUInt + +{- | +Obtains the alignment for the ruby text contained in a +inline-level structure element. + +/Since: 0.26/ +-} +structureElementGetRubyAlign :: + (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) => + a + {- ^ /@popplerStructureElement@/: A 'GI.Poppler.Objects.StructureElement.StructureElement' -} + -> m Poppler.Enums.StructureRubyAlign + {- ^ __Returns:__ A 'GI.Poppler.Enums.StructureRubyAlign' value. -} +structureElementGetRubyAlign popplerStructureElement = liftIO $ do + popplerStructureElement' <- unsafeManagedPtrCastPtr popplerStructureElement + result <- poppler_structure_element_get_ruby_align popplerStructureElement' + let result' = (toEnum . fromIntegral) result + touchManagedPtr popplerStructureElement + return result' + +#if ENABLE_OVERLOADING +data StructureElementGetRubyAlignMethodInfo +instance (signature ~ (m Poppler.Enums.StructureRubyAlign), MonadIO m, IsStructureElement a) => O.MethodInfo StructureElementGetRubyAlignMethodInfo a signature where + overloadedMethod _ = structureElementGetRubyAlign + +#endif + +-- method StructureElement::get_ruby_position +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_structure_element", argType = TInterface (Name {namespace = "Poppler", name = "StructureElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerStructureElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "StructureRubyPosition"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_structure_element_get_ruby_position" poppler_structure_element_get_ruby_position :: + Ptr StructureElement -> -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"}) + IO CUInt + +{- | +Obtains the position for the ruby text contained in a +inline-level structure element. + +/Since: 0.26/ +-} +structureElementGetRubyPosition :: + (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) => + a + {- ^ /@popplerStructureElement@/: A 'GI.Poppler.Objects.StructureElement.StructureElement' -} + -> m Poppler.Enums.StructureRubyPosition + {- ^ __Returns:__ A 'GI.Poppler.Enums.StructureRubyPosition' value. -} +structureElementGetRubyPosition popplerStructureElement = liftIO $ do + popplerStructureElement' <- unsafeManagedPtrCastPtr popplerStructureElement + result <- poppler_structure_element_get_ruby_position popplerStructureElement' + let result' = (toEnum . fromIntegral) result + touchManagedPtr popplerStructureElement + return result' + +#if ENABLE_OVERLOADING +data StructureElementGetRubyPositionMethodInfo +instance (signature ~ (m Poppler.Enums.StructureRubyPosition), MonadIO m, IsStructureElement a) => O.MethodInfo StructureElementGetRubyPositionMethodInfo a signature where + overloadedMethod _ = structureElementGetRubyPosition + +#endif + +-- method StructureElement::get_space_after +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_structure_element", argType = TInterface (Name {namespace = "Poppler", name = "StructureElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerStructureElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TDouble) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_structure_element_get_space_after" poppler_structure_element_get_space_after :: + Ptr StructureElement -> -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"}) + IO CDouble + +{- | +Obtains the amount of empty space after the block-level structure element. + +/Since: 0.26/ +-} +structureElementGetSpaceAfter :: + (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) => + a + {- ^ /@popplerStructureElement@/: A 'GI.Poppler.Objects.StructureElement.StructureElement' -} + -> m Double + {- ^ __Returns:__ A positive value. -} +structureElementGetSpaceAfter popplerStructureElement = liftIO $ do + popplerStructureElement' <- unsafeManagedPtrCastPtr popplerStructureElement + result <- poppler_structure_element_get_space_after popplerStructureElement' + let result' = realToFrac result + touchManagedPtr popplerStructureElement + return result' + +#if ENABLE_OVERLOADING +data StructureElementGetSpaceAfterMethodInfo +instance (signature ~ (m Double), MonadIO m, IsStructureElement a) => O.MethodInfo StructureElementGetSpaceAfterMethodInfo a signature where + overloadedMethod _ = structureElementGetSpaceAfter + +#endif + +-- method StructureElement::get_space_before +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_structure_element", argType = TInterface (Name {namespace = "Poppler", name = "StructureElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerStructureElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TDouble) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_structure_element_get_space_before" poppler_structure_element_get_space_before :: + Ptr StructureElement -> -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"}) + IO CDouble + +{- | +Obtains the amount of empty space before the block-level structure element. + +/Since: 0.26/ +-} +structureElementGetSpaceBefore :: + (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) => + a + {- ^ /@popplerStructureElement@/: A 'GI.Poppler.Objects.StructureElement.StructureElement' -} + -> m Double + {- ^ __Returns:__ A positive value. -} +structureElementGetSpaceBefore popplerStructureElement = liftIO $ do + popplerStructureElement' <- unsafeManagedPtrCastPtr popplerStructureElement + result <- poppler_structure_element_get_space_before popplerStructureElement' + let result' = realToFrac result + touchManagedPtr popplerStructureElement + return result' + +#if ENABLE_OVERLOADING +data StructureElementGetSpaceBeforeMethodInfo +instance (signature ~ (m Double), MonadIO m, IsStructureElement a) => O.MethodInfo StructureElementGetSpaceBeforeMethodInfo a signature where + overloadedMethod _ = structureElementGetSpaceBefore + +#endif + +-- method StructureElement::get_start_indent +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_structure_element", argType = TInterface (Name {namespace = "Poppler", name = "StructureElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerStructureElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TDouble) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_structure_element_get_start_indent" poppler_structure_element_get_start_indent :: + Ptr StructureElement -> -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"}) + IO CDouble + +{- | +Obtains the amount of indentation at the beginning of the block-level structure element. + +/Since: 0.26/ +-} +structureElementGetStartIndent :: + (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) => + a + {- ^ /@popplerStructureElement@/: A 'GI.Poppler.Objects.StructureElement.StructureElement' -} + -> m Double + {- ^ __Returns:__ A numeric value. -} +structureElementGetStartIndent popplerStructureElement = liftIO $ do + popplerStructureElement' <- unsafeManagedPtrCastPtr popplerStructureElement + result <- poppler_structure_element_get_start_indent popplerStructureElement' + let result' = realToFrac result + touchManagedPtr popplerStructureElement + return result' + +#if ENABLE_OVERLOADING +data StructureElementGetStartIndentMethodInfo +instance (signature ~ (m Double), MonadIO m, IsStructureElement a) => O.MethodInfo StructureElementGetStartIndentMethodInfo a signature where + overloadedMethod _ = structureElementGetStartIndent + +#endif + +-- method StructureElement::get_table_border_style +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_structure_element", argType = TInterface (Name {namespace = "Poppler", name = "StructureElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerStructureElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "border_styles", argType = TCArray False 4 (-1) (TInterface (Name {namespace = "Poppler", name = "StructureBorderStyle"})), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "\n An array of four #PopplerStructureBorderStyle elements.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_structure_element_get_table_border_style" poppler_structure_element_get_table_border_style :: + Ptr StructureElement -> -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"}) + Ptr (Ptr CUInt) -> -- border_styles : TCArray False 4 (-1) (TInterface (Name {namespace = "Poppler", name = "StructureBorderStyle"})) + IO () + +{- | +Obtains the table cell border style of a block-level structure element. The result values +are in before-after-start-end ordering. For example, using Western +left-to-right writing, that is top-bottom-left-right. + +/Since: 0.26/ +-} +structureElementGetTableBorderStyle :: + (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) => + a + {- ^ /@popplerStructureElement@/: A 'GI.Poppler.Objects.StructureElement.StructureElement' -} + -> m ([Poppler.Enums.StructureBorderStyle]) +structureElementGetTableBorderStyle popplerStructureElement = liftIO $ do + popplerStructureElement' <- unsafeManagedPtrCastPtr popplerStructureElement + borderStyles <- allocMem :: IO (Ptr (Ptr CUInt)) + poppler_structure_element_get_table_border_style popplerStructureElement' borderStyles + borderStyles' <- peek borderStyles + borderStyles'' <- (unpackStorableArrayWithLength 4) borderStyles' + let borderStyles''' = map (toEnum . fromIntegral) borderStyles'' + freeMem borderStyles' + touchManagedPtr popplerStructureElement + freeMem borderStyles + return borderStyles''' + +#if ENABLE_OVERLOADING +data StructureElementGetTableBorderStyleMethodInfo +instance (signature ~ (m ([Poppler.Enums.StructureBorderStyle])), MonadIO m, IsStructureElement a) => O.MethodInfo StructureElementGetTableBorderStyleMethodInfo a signature where + overloadedMethod _ = structureElementGetTableBorderStyle + +#endif + +-- method StructureElement::get_table_column_span +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_structure_element", argType = TInterface (Name {namespace = "Poppler", name = "StructureElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerStructureElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_structure_element_get_table_column_span" poppler_structure_element_get_table_column_span :: + Ptr StructureElement -> -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"}) + IO Word32 + +{- | +Obtains the number of columns the table element spans to. + +/Since: 0.26/ +-} +structureElementGetTableColumnSpan :: + (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) => + a + {- ^ /@popplerStructureElement@/: A 'GI.Poppler.Objects.StructureElement.StructureElement' -} + -> m Word32 + {- ^ __Returns:__ A positive, non-zero value. -} +structureElementGetTableColumnSpan popplerStructureElement = liftIO $ do + popplerStructureElement' <- unsafeManagedPtrCastPtr popplerStructureElement + result <- poppler_structure_element_get_table_column_span popplerStructureElement' + touchManagedPtr popplerStructureElement + return result + +#if ENABLE_OVERLOADING +data StructureElementGetTableColumnSpanMethodInfo +instance (signature ~ (m Word32), MonadIO m, IsStructureElement a) => O.MethodInfo StructureElementGetTableColumnSpanMethodInfo a signature where + overloadedMethod _ = structureElementGetTableColumnSpan + +#endif + +-- method StructureElement::get_table_headers +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_structure_element", argType = TInterface (Name {namespace = "Poppler", name = "StructureElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerStructureElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (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 -> -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"}) + IO (Ptr CString) + +{- | +Obtains an array with the names of the table column headers. This is only +useful for table header row elements. + +The array with the results is allocated by the function. The number +of items in the returned array can be obtained with 'GI.GLib.Functions.strvLength'. +The returned value must be freed using 'GI.GLib.Functions.strfreev'. + +/Since: 0.26/ +-} +structureElementGetTableHeaders :: + (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) => + a + {- ^ /@popplerStructureElement@/: A 'GI.Poppler.Objects.StructureElement.StructureElement' -} + -> m [T.Text] + {- ^ __Returns:__ + Zero-terminated array of strings with the table header names, + or 'Nothing' if the attribute is not defined. -} +structureElementGetTableHeaders popplerStructureElement = liftIO $ do + popplerStructureElement' <- unsafeManagedPtrCastPtr popplerStructureElement + result <- poppler_structure_element_get_table_headers popplerStructureElement' + checkUnexpectedReturnNULL "structureElementGetTableHeaders" result + result' <- unpackZeroTerminatedUTF8CArray result + mapZeroTerminatedCArray freeMem result + freeMem result + touchManagedPtr popplerStructureElement + return result' + +#if ENABLE_OVERLOADING +data StructureElementGetTableHeadersMethodInfo +instance (signature ~ (m [T.Text]), MonadIO m, IsStructureElement a) => O.MethodInfo StructureElementGetTableHeadersMethodInfo a signature where + overloadedMethod _ = structureElementGetTableHeaders + +#endif + +-- method StructureElement::get_table_padding +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_structure_element", argType = TInterface (Name {namespace = "Poppler", name = "StructureElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerStructureElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "paddings", argType = TCArray False 4 (-1) (TBasicType TDouble), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "\n Padding for the four sides of the element.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_structure_element_get_table_padding" poppler_structure_element_get_table_padding :: + Ptr StructureElement -> -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"}) + Ptr (Ptr CDouble) -> -- paddings : TCArray False 4 (-1) (TBasicType TDouble) + IO () + +{- | +Obtains the padding between the table cell’s content rectangle and the +surrounding border of a block-level structure element. The result +values are in before-after-start-end ordering (for the typical +Western left-to-right writing, that is top-bottom-left-right). + +/Since: 0.26/ +-} +structureElementGetTablePadding :: + (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) => + a + {- ^ /@popplerStructureElement@/: A 'GI.Poppler.Objects.StructureElement.StructureElement' -} + -> m ([Double]) +structureElementGetTablePadding popplerStructureElement = liftIO $ do + popplerStructureElement' <- unsafeManagedPtrCastPtr popplerStructureElement + paddings <- allocMem :: IO (Ptr (Ptr CDouble)) + poppler_structure_element_get_table_padding popplerStructureElement' paddings + paddings' <- peek paddings + paddings'' <- (unpackMapStorableArrayWithLength realToFrac 4) paddings' + freeMem paddings' + touchManagedPtr popplerStructureElement + freeMem paddings + return paddings'' + +#if ENABLE_OVERLOADING +data StructureElementGetTablePaddingMethodInfo +instance (signature ~ (m ([Double])), MonadIO m, IsStructureElement a) => O.MethodInfo StructureElementGetTablePaddingMethodInfo a signature where + overloadedMethod _ = structureElementGetTablePadding + +#endif + +-- method StructureElement::get_table_row_span +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_structure_element", argType = TInterface (Name {namespace = "Poppler", name = "StructureElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerStructureElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_structure_element_get_table_row_span" poppler_structure_element_get_table_row_span :: + Ptr StructureElement -> -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"}) + IO Word32 + +{- | +Obtains the number of rows the table element spans to. + +/Since: 0.26/ +-} +structureElementGetTableRowSpan :: + (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) => + a + {- ^ /@popplerStructureElement@/: A 'GI.Poppler.Objects.StructureElement.StructureElement' -} + -> m Word32 + {- ^ __Returns:__ A positive, non-zero value. -} +structureElementGetTableRowSpan popplerStructureElement = liftIO $ do + popplerStructureElement' <- unsafeManagedPtrCastPtr popplerStructureElement + result <- poppler_structure_element_get_table_row_span popplerStructureElement' + touchManagedPtr popplerStructureElement + return result + +#if ENABLE_OVERLOADING +data StructureElementGetTableRowSpanMethodInfo +instance (signature ~ (m Word32), MonadIO m, IsStructureElement a) => O.MethodInfo StructureElementGetTableRowSpanMethodInfo a signature where + overloadedMethod _ = structureElementGetTableRowSpan + +#endif + +-- method StructureElement::get_table_scope +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_structure_element", argType = TInterface (Name {namespace = "Poppler", name = "StructureElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerStructureElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "StructureTableScope"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_structure_element_get_table_scope" poppler_structure_element_get_table_scope :: + Ptr StructureElement -> -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"}) + IO CUInt + +{- | +Obtains the scope of a table structure element. + +/Since: 0.26/ +-} +structureElementGetTableScope :: + (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) => + a + {- ^ /@popplerStructureElement@/: A 'GI.Poppler.Objects.StructureElement.StructureElement' -} + -> m Poppler.Enums.StructureTableScope + {- ^ __Returns:__ A 'GI.Poppler.Enums.StructureTableScope' value. -} +structureElementGetTableScope popplerStructureElement = liftIO $ do + popplerStructureElement' <- unsafeManagedPtrCastPtr popplerStructureElement + result <- poppler_structure_element_get_table_scope popplerStructureElement' + let result' = (toEnum . fromIntegral) result + touchManagedPtr popplerStructureElement + return result' + +#if ENABLE_OVERLOADING +data StructureElementGetTableScopeMethodInfo +instance (signature ~ (m Poppler.Enums.StructureTableScope), MonadIO m, IsStructureElement a) => O.MethodInfo StructureElementGetTableScopeMethodInfo a signature where + overloadedMethod _ = structureElementGetTableScope + +#endif + +-- method StructureElement::get_table_summary +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_structure_element", argType = TInterface (Name {namespace = "Poppler", name = "StructureElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerStructureElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_structure_element_get_table_summary" poppler_structure_element_get_table_summary :: + Ptr StructureElement -> -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"}) + IO CString + +{- | +Obtains the textual summary of the contents of the table element. Note that +the summary is meant for informative purposes, and it is not intended +to be rendered. For example, assistive technologies may use the +description field to provide an alternate way of presenting an element +to the user, or a document indexer may want to scan it for additional +keywords. + +The returned string is allocated by the function. When it is +not needed anymore, be sure to call 'GI.GLib.Functions.free' on it. + +/Since: 0.26/ +-} +structureElementGetTableSummary :: + (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) => + a + {- ^ /@popplerStructureElement@/: A 'GI.Poppler.Objects.StructureElement.StructureElement' -} + -> m T.Text + {- ^ __Returns:__ A string, or 'Nothing' if the attribute + is not defined. -} +structureElementGetTableSummary popplerStructureElement = liftIO $ do + popplerStructureElement' <- unsafeManagedPtrCastPtr popplerStructureElement + result <- poppler_structure_element_get_table_summary popplerStructureElement' + checkUnexpectedReturnNULL "structureElementGetTableSummary" result + result' <- cstringToText result + freeMem result + touchManagedPtr popplerStructureElement + return result' + +#if ENABLE_OVERLOADING +data StructureElementGetTableSummaryMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsStructureElement a) => O.MethodInfo StructureElementGetTableSummaryMethodInfo a signature where + overloadedMethod _ = structureElementGetTableSummary + +#endif + +-- method StructureElement::get_text +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_structure_element", argType = TInterface (Name {namespace = "Poppler", name = "StructureElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerStructureElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Poppler", name = "StructureGetTextFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerStructureGetTextFlags value, or\n %POPPLER_STRUCTURE_GET_TEXT_NONE to disable all the flags.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_structure_element_get_text" poppler_structure_element_get_text :: + Ptr StructureElement -> -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"}) + CUInt -> -- flags : TInterface (Name {namespace = "Poppler", name = "StructureGetTextFlags"}) + IO CString + +{- | +Obtains the text enclosed by an element, or the text enclosed by the +elements in the subtree (including the element itself). + +/Since: 0.26/ +-} +structureElementGetText :: + (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) => + a + {- ^ /@popplerStructureElement@/: A 'GI.Poppler.Objects.StructureElement.StructureElement' -} + -> [Poppler.Flags.StructureGetTextFlags] + {- ^ /@flags@/: A 'GI.Poppler.Flags.StructureGetTextFlags' value, or + 'GI.Poppler.Flags.StructureGetTextFlagsNone' to disable all the flags. -} + -> m T.Text + {- ^ __Returns:__ A string. -} +structureElementGetText popplerStructureElement flags = liftIO $ do + popplerStructureElement' <- unsafeManagedPtrCastPtr popplerStructureElement + let flags' = gflagsToWord flags + result <- poppler_structure_element_get_text popplerStructureElement' flags' + checkUnexpectedReturnNULL "structureElementGetText" result + result' <- cstringToText result + freeMem result + touchManagedPtr popplerStructureElement + return result' + +#if ENABLE_OVERLOADING +data StructureElementGetTextMethodInfo +instance (signature ~ ([Poppler.Flags.StructureGetTextFlags] -> m T.Text), MonadIO m, IsStructureElement a) => O.MethodInfo StructureElementGetTextMethodInfo a signature where + overloadedMethod _ = structureElementGetText + +#endif + +-- method StructureElement::get_text_align +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_structure_element", argType = TInterface (Name {namespace = "Poppler", name = "StructureElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerStructureElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "StructureTextAlign"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_structure_element_get_text_align" poppler_structure_element_get_text_align :: + Ptr StructureElement -> -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"}) + IO CUInt + +{- | +Obtains the text alignment mode of the text contained into a +block-level structure element. + +/Since: 0.26/ +-} +structureElementGetTextAlign :: + (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) => + a + {- ^ /@popplerStructureElement@/: A 'GI.Poppler.Objects.StructureElement.StructureElement' -} + -> m Poppler.Enums.StructureTextAlign + {- ^ __Returns:__ A 'GI.Poppler.Enums.StructureTextAlign' value. -} +structureElementGetTextAlign popplerStructureElement = liftIO $ do + popplerStructureElement' <- unsafeManagedPtrCastPtr popplerStructureElement + result <- poppler_structure_element_get_text_align popplerStructureElement' + let result' = (toEnum . fromIntegral) result + touchManagedPtr popplerStructureElement + return result' + +#if ENABLE_OVERLOADING +data StructureElementGetTextAlignMethodInfo +instance (signature ~ (m Poppler.Enums.StructureTextAlign), MonadIO m, IsStructureElement a) => O.MethodInfo StructureElementGetTextAlignMethodInfo a signature where + overloadedMethod _ = structureElementGetTextAlign + +#endif + +-- method StructureElement::get_text_decoration_color +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_structure_element", argType = TInterface (Name {namespace = "Poppler", name = "StructureElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerStructureElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "color", argType = TInterface (Name {namespace = "Poppler", name = "Color"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerColor.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_structure_element_get_text_decoration_color" poppler_structure_element_get_text_decoration_color :: + Ptr StructureElement -> -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"}) + Ptr Poppler.Color.Color -> -- color : TInterface (Name {namespace = "Poppler", name = "Color"}) + IO CInt + +{- | +Obtains the color of the text decoration for the text contained +in the inline-level structure element. +If this attribute is not specified, the color for this element shall be the current fill +color in effect at the start of its associated content. + +/Since: 0.26/ +-} +structureElementGetTextDecorationColor :: + (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) => + a + {- ^ /@popplerStructureElement@/: A 'GI.Poppler.Objects.StructureElement.StructureElement' -} + -> m ((Bool, Poppler.Color.Color)) + {- ^ __Returns:__ 'True' if a color is defined for the element, + 'False' otherwise. -} +structureElementGetTextDecorationColor popplerStructureElement = liftIO $ do + popplerStructureElement' <- unsafeManagedPtrCastPtr popplerStructureElement + color <- callocBoxedBytes 6 :: IO (Ptr Poppler.Color.Color) + result <- poppler_structure_element_get_text_decoration_color popplerStructureElement' color + let result' = (/= 0) result + color' <- (wrapBoxed Poppler.Color.Color) color + touchManagedPtr popplerStructureElement + return (result', color') + +#if ENABLE_OVERLOADING +data StructureElementGetTextDecorationColorMethodInfo +instance (signature ~ (m ((Bool, Poppler.Color.Color))), MonadIO m, IsStructureElement a) => O.MethodInfo StructureElementGetTextDecorationColorMethodInfo a signature where + overloadedMethod _ = structureElementGetTextDecorationColor + +#endif + +-- method StructureElement::get_text_decoration_thickness +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_structure_element", argType = TInterface (Name {namespace = "Poppler", name = "StructureElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerStructureElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TDouble) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_structure_element_get_text_decoration_thickness" poppler_structure_element_get_text_decoration_thickness :: + Ptr StructureElement -> -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"}) + IO CDouble + +{- | +Obtains the thickness of the text decoration for the text contained +in the inline-level structure element. +If this attribute is not specified, it shall be derived from the current +stroke thickness in effect at the start of the element’s associated content. + +/Since: 0.26/ +-} +structureElementGetTextDecorationThickness :: + (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) => + a + {- ^ /@popplerStructureElement@/: A 'GI.Poppler.Objects.StructureElement.StructureElement' -} + -> m Double + {- ^ __Returns:__ Thickness of the text decoration, or NAN if not defined. -} +structureElementGetTextDecorationThickness popplerStructureElement = liftIO $ do + popplerStructureElement' <- unsafeManagedPtrCastPtr popplerStructureElement + result <- poppler_structure_element_get_text_decoration_thickness popplerStructureElement' + let result' = realToFrac result + touchManagedPtr popplerStructureElement + return result' + +#if ENABLE_OVERLOADING +data StructureElementGetTextDecorationThicknessMethodInfo +instance (signature ~ (m Double), MonadIO m, IsStructureElement a) => O.MethodInfo StructureElementGetTextDecorationThicknessMethodInfo a signature where + overloadedMethod _ = structureElementGetTextDecorationThickness + +#endif + +-- method StructureElement::get_text_decoration_type +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_structure_element", argType = TInterface (Name {namespace = "Poppler", name = "StructureElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerStructureElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "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 -> -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"}) + IO CUInt + +{- | +Obtains the text decoration type of the text contained in the +inline-level structure element. + +/Since: 0.26/ +-} +structureElementGetTextDecorationType :: + (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) => + a + {- ^ /@popplerStructureElement@/: A 'GI.Poppler.Objects.StructureElement.StructureElement' -} + -> m Poppler.Enums.StructureTextDecoration + {- ^ __Returns:__ A 'GI.Poppler.Enums.StructureTextDecoration' value. -} +structureElementGetTextDecorationType popplerStructureElement = liftIO $ do + popplerStructureElement' <- unsafeManagedPtrCastPtr popplerStructureElement + result <- poppler_structure_element_get_text_decoration_type popplerStructureElement' + let result' = (toEnum . fromIntegral) result + touchManagedPtr popplerStructureElement + return result' + +#if ENABLE_OVERLOADING +data StructureElementGetTextDecorationTypeMethodInfo +instance (signature ~ (m Poppler.Enums.StructureTextDecoration), MonadIO m, IsStructureElement a) => O.MethodInfo StructureElementGetTextDecorationTypeMethodInfo a signature where + overloadedMethod _ = structureElementGetTextDecorationType + +#endif + +-- method StructureElement::get_text_indent +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_structure_element", argType = TInterface (Name {namespace = "Poppler", name = "StructureElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerStructureElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TDouble) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_structure_element_get_text_indent" poppler_structure_element_get_text_indent :: + Ptr StructureElement -> -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"}) + IO CDouble + +{- | +Obtains the amount of indentation of the text contained in the block-level structure element. + +/Since: 0.26/ +-} +structureElementGetTextIndent :: + (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) => + a + {- ^ /@popplerStructureElement@/: A 'GI.Poppler.Objects.StructureElement.StructureElement' -} + -> m Double + {- ^ __Returns:__ A numeric value. -} +structureElementGetTextIndent popplerStructureElement = liftIO $ do + popplerStructureElement' <- unsafeManagedPtrCastPtr popplerStructureElement + result <- poppler_structure_element_get_text_indent popplerStructureElement' + let result' = realToFrac result + touchManagedPtr popplerStructureElement + return result' + +#if ENABLE_OVERLOADING +data StructureElementGetTextIndentMethodInfo +instance (signature ~ (m Double), MonadIO m, IsStructureElement a) => O.MethodInfo StructureElementGetTextIndentMethodInfo a signature where + overloadedMethod _ = structureElementGetTextIndent + +#endif + +-- method StructureElement::get_text_spans +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_structure_element", argType = TInterface (Name {namespace = "Poppler", name = "StructureElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerStructureElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_text_spans", argType = TBasicType TUInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A pointer to the location where the number of elements in\n the returned array will be stored.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [Arg {argCName = "n_text_spans", argType = TBasicType TUInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A pointer to the location where the number of elements in\n the returned array will be stored.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- returnType : Just (TCArray False (-1) 1 (TInterface (Name {namespace = "Poppler", name = "TextSpan"}))) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_structure_element_get_text_spans" poppler_structure_element_get_text_spans :: + Ptr StructureElement -> -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"}) + Ptr Word32 -> -- n_text_spans : TBasicType TUInt + IO (Ptr (Ptr Poppler.TextSpan.TextSpan)) + +{- | +Obtains the text enclosed by an element, as an array of 'GI.Poppler.Structs.TextSpan.TextSpan' +structures. Each item in the list is a piece of text which share the same +attributes, plus its attributes. The following example shows how to +obtain and free the text spans of an element: + +\\ +guint i, n_spans; +PopplerTextSpan **text_spans = + poppler_structure_element_get_text_spans (element, &n_spans); +\/\* Use the text spans *\\/ +for (i = 0; i \< n_spans; i++) + poppler_text_span_free (text_spans[i]); +g_free (text_spans); +\<\/programlisting>\<\/informalexample> + +/Since: 0.26/ +-} +structureElementGetTextSpans :: + (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) => + a + {- ^ /@popplerStructureElement@/: A 'GI.Poppler.Objects.StructureElement.StructureElement' -} + -> m [Poppler.TextSpan.TextSpan] + {- ^ __Returns:__ + An array of 'GI.Poppler.Structs.TextSpan.TextSpan' elements. -} +structureElementGetTextSpans popplerStructureElement = liftIO $ do + popplerStructureElement' <- unsafeManagedPtrCastPtr popplerStructureElement + nTextSpans <- allocMem :: IO (Ptr Word32) + result <- poppler_structure_element_get_text_spans popplerStructureElement' nTextSpans + nTextSpans' <- peek nTextSpans + checkUnexpectedReturnNULL "structureElementGetTextSpans" result + result' <- (unpackPtrArrayWithLength nTextSpans') result + result'' <- mapM (wrapBoxed Poppler.TextSpan.TextSpan) result' + freeMem result + touchManagedPtr popplerStructureElement + freeMem nTextSpans + return result'' + +#if ENABLE_OVERLOADING +data StructureElementGetTextSpansMethodInfo +instance (signature ~ (m [Poppler.TextSpan.TextSpan]), MonadIO m, IsStructureElement a) => O.MethodInfo StructureElementGetTextSpansMethodInfo a signature where + overloadedMethod _ = structureElementGetTextSpans + +#endif + +-- method StructureElement::get_title +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_structure_element", argType = TInterface (Name {namespace = "Poppler", name = "StructureElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerStructureElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_structure_element_get_title" poppler_structure_element_get_title :: + Ptr StructureElement -> -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"}) + IO CString + +{- | +Obtains the title of an element. + +/Since: 0.26/ +-} +structureElementGetTitle :: + (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) => + a + {- ^ /@popplerStructureElement@/: A 'GI.Poppler.Objects.StructureElement.StructureElement' -} + -> m T.Text + {- ^ __Returns:__ The title of the element, or 'Nothing'. -} +structureElementGetTitle popplerStructureElement = liftIO $ do + popplerStructureElement' <- unsafeManagedPtrCastPtr popplerStructureElement + result <- poppler_structure_element_get_title popplerStructureElement' + checkUnexpectedReturnNULL "structureElementGetTitle" result + result' <- cstringToText result + freeMem result + touchManagedPtr popplerStructureElement + return result' + +#if ENABLE_OVERLOADING +data StructureElementGetTitleMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsStructureElement a) => O.MethodInfo StructureElementGetTitleMethodInfo a signature where + overloadedMethod _ = structureElementGetTitle + +#endif + +-- method StructureElement::get_width +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_structure_element", argType = TInterface (Name {namespace = "Poppler", name = "StructureElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerStructureElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TDouble) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_structure_element_get_width" poppler_structure_element_get_width :: + Ptr StructureElement -> -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"}) + IO CDouble + +{- | +Obtains the width of the block-level structure element. Note that for elements which do +not specify a width, it has to be calculated, and in this case -1 is returned. + +/Since: 0.26/ +-} +structureElementGetWidth :: + (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) => + a + {- ^ /@popplerStructureElement@/: A 'GI.Poppler.Objects.StructureElement.StructureElement' -} + -> m Double + {- ^ __Returns:__ A positive value if a width is defined, or -1 + if the width is to be calculated automatically. -} +structureElementGetWidth popplerStructureElement = liftIO $ do + popplerStructureElement' <- unsafeManagedPtrCastPtr popplerStructureElement + result <- poppler_structure_element_get_width popplerStructureElement' + let result' = realToFrac result + touchManagedPtr popplerStructureElement + return result' + +#if ENABLE_OVERLOADING +data StructureElementGetWidthMethodInfo +instance (signature ~ (m Double), MonadIO m, IsStructureElement a) => O.MethodInfo StructureElementGetWidthMethodInfo a signature where + overloadedMethod _ = structureElementGetWidth + +#endif + +-- method StructureElement::get_writing_mode +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_structure_element", argType = TInterface (Name {namespace = "Poppler", name = "StructureElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerStructureElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "StructureWritingMode"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_structure_element_get_writing_mode" poppler_structure_element_get_writing_mode :: + Ptr StructureElement -> -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"}) + IO CUInt + +{- | +Obtains the writing mode (writing direction) of the content associated +with a structure element. + +/Since: 0.26/ +-} +structureElementGetWritingMode :: + (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) => + a + {- ^ /@popplerStructureElement@/: A 'GI.Poppler.Objects.StructureElement.StructureElement' -} + -> m Poppler.Enums.StructureWritingMode + {- ^ __Returns:__ A 'GI.Poppler.Enums.StructureWritingMode' value. -} +structureElementGetWritingMode popplerStructureElement = liftIO $ do + popplerStructureElement' <- unsafeManagedPtrCastPtr popplerStructureElement + result <- poppler_structure_element_get_writing_mode popplerStructureElement' + let result' = (toEnum . fromIntegral) result + touchManagedPtr popplerStructureElement + return result' + +#if ENABLE_OVERLOADING +data StructureElementGetWritingModeMethodInfo +instance (signature ~ (m Poppler.Enums.StructureWritingMode), MonadIO m, IsStructureElement a) => O.MethodInfo StructureElementGetWritingModeMethodInfo a signature where + overloadedMethod _ = structureElementGetWritingMode + +#endif + +-- method StructureElement::is_block +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_structure_element", argType = TInterface (Name {namespace = "Poppler", name = "StructureElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerStructureElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_structure_element_is_block" poppler_structure_element_is_block :: + Ptr StructureElement -> -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"}) + IO CInt + +{- | +Checks whether an element is a block element. + +/Since: 0.26/ +-} +structureElementIsBlock :: + (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) => + a + {- ^ /@popplerStructureElement@/: A 'GI.Poppler.Objects.StructureElement.StructureElement' -} + -> m Bool + {- ^ __Returns:__ 'True' if the element is a block element, or 'False' otherwise. -} +structureElementIsBlock popplerStructureElement = liftIO $ do + popplerStructureElement' <- unsafeManagedPtrCastPtr popplerStructureElement + result <- poppler_structure_element_is_block popplerStructureElement' + let result' = (/= 0) result + touchManagedPtr popplerStructureElement + return result' + +#if ENABLE_OVERLOADING +data StructureElementIsBlockMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsStructureElement a) => O.MethodInfo StructureElementIsBlockMethodInfo a signature where + overloadedMethod _ = structureElementIsBlock + +#endif + +-- method StructureElement::is_content +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_structure_element", argType = TInterface (Name {namespace = "Poppler", name = "StructureElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerStructureElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_structure_element_is_content" poppler_structure_element_is_content :: + Ptr StructureElement -> -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"}) + IO CInt + +{- | +Checks whether an element is actual document content. + +/Since: 0.26/ +-} +structureElementIsContent :: + (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) => + a + {- ^ /@popplerStructureElement@/: A 'GI.Poppler.Objects.StructureElement.StructureElement' -} + -> m Bool + {- ^ __Returns:__ 'True' if the element is content, or 'False' otherwise. -} +structureElementIsContent popplerStructureElement = liftIO $ do + popplerStructureElement' <- unsafeManagedPtrCastPtr popplerStructureElement + result <- poppler_structure_element_is_content popplerStructureElement' + let result' = (/= 0) result + touchManagedPtr popplerStructureElement + return result' + +#if ENABLE_OVERLOADING +data StructureElementIsContentMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsStructureElement a) => O.MethodInfo StructureElementIsContentMethodInfo a signature where + overloadedMethod _ = structureElementIsContent + +#endif + +-- method StructureElement::is_grouping +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_structure_element", argType = TInterface (Name {namespace = "Poppler", name = "StructureElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerStructureElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_structure_element_is_grouping" poppler_structure_element_is_grouping :: + Ptr StructureElement -> -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"}) + IO CInt + +{- | +Checks whether an element is a grouping element. + +/Since: 0.26/ +-} +structureElementIsGrouping :: + (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) => + a + {- ^ /@popplerStructureElement@/: A 'GI.Poppler.Objects.StructureElement.StructureElement' -} + -> m Bool + {- ^ __Returns:__ 'True' if the element is a grouping element, 'False' + otherwise. -} +structureElementIsGrouping popplerStructureElement = liftIO $ do + popplerStructureElement' <- unsafeManagedPtrCastPtr popplerStructureElement + result <- poppler_structure_element_is_grouping popplerStructureElement' + let result' = (/= 0) result + touchManagedPtr popplerStructureElement + return result' + +#if ENABLE_OVERLOADING +data StructureElementIsGroupingMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsStructureElement a) => O.MethodInfo StructureElementIsGroupingMethodInfo a signature where + overloadedMethod _ = structureElementIsGrouping + +#endif + +-- method StructureElement::is_inline +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_structure_element", argType = TInterface (Name {namespace = "Poppler", name = "StructureElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerStructureElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_structure_element_is_inline" poppler_structure_element_is_inline :: + Ptr StructureElement -> -- poppler_structure_element : TInterface (Name {namespace = "Poppler", name = "StructureElement"}) + IO CInt + +{- | +Checks whether an element is an inline element. + +/Since: 0.26/ +-} +structureElementIsInline :: + (B.CallStack.HasCallStack, MonadIO m, IsStructureElement a) => + a + {- ^ /@popplerStructureElement@/: A 'GI.Poppler.Objects.StructureElement.StructureElement' -} + -> m Bool + {- ^ __Returns:__ 'True' if the element is an inline element, or 'False' otherwise. -} +structureElementIsInline popplerStructureElement = liftIO $ do + popplerStructureElement' <- unsafeManagedPtrCastPtr popplerStructureElement + result <- poppler_structure_element_is_inline popplerStructureElement' + let result' = (/= 0) result + touchManagedPtr popplerStructureElement + return result' + +#if ENABLE_OVERLOADING +data StructureElementIsInlineMethodInfo +instance (signature ~ (m Bool), MonadIO m, IsStructureElement a) => O.MethodInfo StructureElementIsInlineMethodInfo a signature where + overloadedMethod _ = structureElementIsInline + +#endif + + 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,194 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Poppler.Objects.StructureElement where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype StructureElement = StructureElement (ManagedPtr StructureElement) +instance GObject StructureElement where +class (GObject o, O.IsDescendantOf StructureElement o) => IsStructureElement o +instance (GObject o, O.IsDescendantOf StructureElement o) => IsStructureElement o +instance O.HasParentTypes StructureElement +#if ENABLE_OVERLOADING +data StructureElementGetAbbreviationMethodInfo +#endif +#if ENABLE_OVERLOADING +data StructureElementGetActualTextMethodInfo +#endif +#if ENABLE_OVERLOADING +data StructureElementGetAltTextMethodInfo +#endif +#if ENABLE_OVERLOADING +data StructureElementGetBackgroundColorMethodInfo +#endif +#if ENABLE_OVERLOADING +data StructureElementGetBaselineShiftMethodInfo +#endif +#if ENABLE_OVERLOADING +data StructureElementGetBlockAlignMethodInfo +#endif +#if ENABLE_OVERLOADING +data StructureElementGetBorderColorMethodInfo +#endif +#if ENABLE_OVERLOADING +data StructureElementGetBorderStyleMethodInfo +#endif +#if ENABLE_OVERLOADING +data StructureElementGetBorderThicknessMethodInfo +#endif +#if ENABLE_OVERLOADING +data StructureElementGetBoundingBoxMethodInfo +#endif +#if ENABLE_OVERLOADING +data StructureElementGetColorMethodInfo +#endif +#if ENABLE_OVERLOADING +data StructureElementGetColumnCountMethodInfo +#endif +#if ENABLE_OVERLOADING +data StructureElementGetColumnGapsMethodInfo +#endif +#if ENABLE_OVERLOADING +data StructureElementGetColumnWidthsMethodInfo +#endif +#if ENABLE_OVERLOADING +data StructureElementGetEndIndentMethodInfo +#endif +#if ENABLE_OVERLOADING +data StructureElementGetFormDescriptionMethodInfo +#endif +#if ENABLE_OVERLOADING +data StructureElementGetFormRoleMethodInfo +#endif +#if ENABLE_OVERLOADING +data StructureElementGetFormStateMethodInfo +#endif +#if ENABLE_OVERLOADING +data StructureElementGetGlyphOrientationMethodInfo +#endif +#if ENABLE_OVERLOADING +data StructureElementGetHeightMethodInfo +#endif +#if ENABLE_OVERLOADING +data StructureElementGetIdMethodInfo +#endif +#if ENABLE_OVERLOADING +data StructureElementGetInlineAlignMethodInfo +#endif +#if ENABLE_OVERLOADING +data StructureElementGetKindMethodInfo +#endif +#if ENABLE_OVERLOADING +data StructureElementGetLanguageMethodInfo +#endif +#if ENABLE_OVERLOADING +data StructureElementGetLineHeightMethodInfo +#endif +#if ENABLE_OVERLOADING +data StructureElementGetListNumberingMethodInfo +#endif +#if ENABLE_OVERLOADING +data StructureElementGetPaddingMethodInfo +#endif +#if ENABLE_OVERLOADING +data StructureElementGetPageMethodInfo +#endif +#if ENABLE_OVERLOADING +data StructureElementGetPlacementMethodInfo +#endif +#if ENABLE_OVERLOADING +data StructureElementGetRubyAlignMethodInfo +#endif +#if ENABLE_OVERLOADING +data StructureElementGetRubyPositionMethodInfo +#endif +#if ENABLE_OVERLOADING +data StructureElementGetSpaceAfterMethodInfo +#endif +#if ENABLE_OVERLOADING +data StructureElementGetSpaceBeforeMethodInfo +#endif +#if ENABLE_OVERLOADING +data StructureElementGetStartIndentMethodInfo +#endif +#if ENABLE_OVERLOADING +data StructureElementGetTableBorderStyleMethodInfo +#endif +#if ENABLE_OVERLOADING +data StructureElementGetTableColumnSpanMethodInfo +#endif +#if ENABLE_OVERLOADING +data StructureElementGetTableHeadersMethodInfo +#endif +#if ENABLE_OVERLOADING +data StructureElementGetTablePaddingMethodInfo +#endif +#if ENABLE_OVERLOADING +data StructureElementGetTableRowSpanMethodInfo +#endif +#if ENABLE_OVERLOADING +data StructureElementGetTableScopeMethodInfo +#endif +#if ENABLE_OVERLOADING +data StructureElementGetTableSummaryMethodInfo +#endif +#if ENABLE_OVERLOADING +data StructureElementGetTextMethodInfo +#endif +#if ENABLE_OVERLOADING +data StructureElementGetTextAlignMethodInfo +#endif +#if ENABLE_OVERLOADING +data StructureElementGetTextDecorationColorMethodInfo +#endif +#if ENABLE_OVERLOADING +data StructureElementGetTextDecorationThicknessMethodInfo +#endif +#if ENABLE_OVERLOADING +data StructureElementGetTextDecorationTypeMethodInfo +#endif +#if ENABLE_OVERLOADING +data StructureElementGetTextIndentMethodInfo +#endif +#if ENABLE_OVERLOADING +data StructureElementGetTextSpansMethodInfo +#endif +#if ENABLE_OVERLOADING +data StructureElementGetTitleMethodInfo +#endif +#if ENABLE_OVERLOADING +data StructureElementGetWidthMethodInfo +#endif +#if ENABLE_OVERLOADING +data StructureElementGetWritingModeMethodInfo +#endif +#if ENABLE_OVERLOADING +data StructureElementIsBlockMethodInfo +#endif +#if ENABLE_OVERLOADING +data StructureElementIsContentMethodInfo +#endif +#if ENABLE_OVERLOADING +data StructureElementIsGroupingMethodInfo +#endif +#if ENABLE_OVERLOADING +data StructureElementIsInlineMethodInfo +#endif 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,95 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +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 Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + + + 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,220 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Poppler.Structs.ActionAny + ( + +-- * Exported types + ActionAny(..) , + newZeroActionAny , + noActionAny , + + + -- * Properties +-- ** title #attr:title# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + actionAny_title , +#endif + clearActionAnyTitle , + getActionAnyTitle , + setActionAnyTitle , + + +-- ** type #attr:type# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + actionAny_type , +#endif + getActionAnyType , + setActionAnyType , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import {-# SOURCE #-} qualified GI.Poppler.Enums as Poppler.Enums + +-- | Memory-managed wrapper type. +newtype ActionAny = ActionAny (ManagedPtr ActionAny) +instance WrappedPtr ActionAny where + wrappedPtrCalloc = callocBytes 16 + wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 16 >=> wrapPtr ActionAny) + wrappedPtrFree = Just ptr_to_g_free + +-- | Construct a `ActionAny` struct initialized to zero. +newZeroActionAny :: MonadIO m => m ActionAny +newZeroActionAny = liftIO $ wrappedPtrCalloc >>= wrapPtr ActionAny + +instance tag ~ 'AttrSet => Constructible ActionAny tag where + new _ attrs = do + o <- newZeroActionAny + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `ActionAny`. +noActionAny :: Maybe ActionAny +noActionAny = Nothing + +{- | +Get the value of the “@type@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' actionAny #type +@ +-} +getActionAnyType :: MonadIO m => ActionAny -> m Poppler.Enums.ActionType +getActionAnyType s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO CUInt + let val' = (toEnum . fromIntegral) val + return val' + +{- | +Set the value of the “@type@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' actionAny [ #type 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setActionAnyType :: MonadIO m => ActionAny -> Poppler.Enums.ActionType -> m () +setActionAnyType s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = (fromIntegral . fromEnum) val + poke (ptr `plusPtr` 0) (val' :: CUInt) + +#if ENABLE_OVERLOADING +data ActionAnyTypeFieldInfo +instance AttrInfo ActionAnyTypeFieldInfo where + type AttrAllowedOps ActionAnyTypeFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint ActionAnyTypeFieldInfo = (~) Poppler.Enums.ActionType + type AttrBaseTypeConstraint ActionAnyTypeFieldInfo = (~) ActionAny + type AttrGetType ActionAnyTypeFieldInfo = Poppler.Enums.ActionType + type AttrLabel ActionAnyTypeFieldInfo = "type" + type AttrOrigin ActionAnyTypeFieldInfo = ActionAny + attrGet _ = getActionAnyType + attrSet _ = setActionAnyType + attrConstruct = undefined + attrClear _ = undefined + +actionAny_type :: AttrLabelProxy "type" +actionAny_type = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@title@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' actionAny #title +@ +-} +getActionAnyTitle :: MonadIO m => ActionAny -> m (Maybe T.Text) +getActionAnyTitle s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 8) :: IO CString + result <- SP.convertIfNonNull val $ \val' -> do + val'' <- cstringToText val' + return val'' + return result + +{- | +Set the value of the “@title@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' actionAny [ #title 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setActionAnyTitle :: MonadIO m => ActionAny -> CString -> m () +setActionAnyTitle s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 8) (val :: CString) + +{- | +Set the value of the “@title@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #title +@ +-} +clearActionAnyTitle :: MonadIO m => ActionAny -> m () +clearActionAnyTitle s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 8) (FP.nullPtr :: CString) + +#if ENABLE_OVERLOADING +data ActionAnyTitleFieldInfo +instance AttrInfo ActionAnyTitleFieldInfo where + type AttrAllowedOps ActionAnyTitleFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint ActionAnyTitleFieldInfo = (~) CString + type AttrBaseTypeConstraint ActionAnyTitleFieldInfo = (~) ActionAny + type AttrGetType ActionAnyTitleFieldInfo = Maybe T.Text + type AttrLabel ActionAnyTitleFieldInfo = "title" + type AttrOrigin ActionAnyTitleFieldInfo = ActionAny + attrGet _ = getActionAnyTitle + attrSet _ = setActionAnyTitle + attrConstruct = undefined + attrClear _ = clearActionAnyTitle + +actionAny_title :: AttrLabelProxy "title" +actionAny_title = AttrLabelProxy + +#endif + + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList ActionAny +type instance O.AttributeList ActionAny = ActionAnyAttributeList +type ActionAnyAttributeList = ('[ '("type", ActionAnyTypeFieldInfo), '("title", ActionAnyTitleFieldInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +type family ResolveActionAnyMethod (t :: Symbol) (o :: *) :: * where + ResolveActionAnyMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveActionAnyMethod t ActionAny, O.MethodInfo info ActionAny p) => OL.IsLabel t (ActionAny -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + 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,26 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Poppler.Structs.ActionAny where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype ActionAny = ActionAny (ManagedPtr ActionAny) +instance WrappedPtr ActionAny where 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,292 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Poppler.Structs.ActionGotoDest + ( + +-- * Exported types + ActionGotoDest(..) , + newZeroActionGotoDest , + noActionGotoDest , + + + -- * Properties +-- ** dest #attr:dest# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + actionGotoDest_dest , +#endif + clearActionGotoDestDest , + getActionGotoDestDest , + setActionGotoDestDest , + + +-- ** title #attr:title# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + actionGotoDest_title , +#endif + clearActionGotoDestTitle , + getActionGotoDestTitle , + setActionGotoDestTitle , + + +-- ** type #attr:type# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + actionGotoDest_type , +#endif + getActionGotoDestType , + setActionGotoDestType , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import {-# SOURCE #-} qualified GI.Poppler.Enums as Poppler.Enums +import {-# SOURCE #-} qualified GI.Poppler.Structs.Dest as Poppler.Dest + +-- | Memory-managed wrapper type. +newtype ActionGotoDest = ActionGotoDest (ManagedPtr ActionGotoDest) +instance WrappedPtr ActionGotoDest where + wrappedPtrCalloc = callocBytes 24 + wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 24 >=> wrapPtr ActionGotoDest) + wrappedPtrFree = Just ptr_to_g_free + +-- | Construct a `ActionGotoDest` struct initialized to zero. +newZeroActionGotoDest :: MonadIO m => m ActionGotoDest +newZeroActionGotoDest = liftIO $ wrappedPtrCalloc >>= wrapPtr ActionGotoDest + +instance tag ~ 'AttrSet => Constructible ActionGotoDest tag where + new _ attrs = do + o <- newZeroActionGotoDest + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `ActionGotoDest`. +noActionGotoDest :: Maybe ActionGotoDest +noActionGotoDest = Nothing + +{- | +Get the value of the “@type@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' actionGotoDest #type +@ +-} +getActionGotoDestType :: MonadIO m => ActionGotoDest -> m Poppler.Enums.ActionType +getActionGotoDestType s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO CUInt + let val' = (toEnum . fromIntegral) val + return val' + +{- | +Set the value of the “@type@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' actionGotoDest [ #type 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setActionGotoDestType :: MonadIO m => ActionGotoDest -> Poppler.Enums.ActionType -> m () +setActionGotoDestType s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = (fromIntegral . fromEnum) val + poke (ptr `plusPtr` 0) (val' :: CUInt) + +#if ENABLE_OVERLOADING +data ActionGotoDestTypeFieldInfo +instance AttrInfo ActionGotoDestTypeFieldInfo where + type AttrAllowedOps ActionGotoDestTypeFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint ActionGotoDestTypeFieldInfo = (~) Poppler.Enums.ActionType + type AttrBaseTypeConstraint ActionGotoDestTypeFieldInfo = (~) ActionGotoDest + type AttrGetType ActionGotoDestTypeFieldInfo = Poppler.Enums.ActionType + type AttrLabel ActionGotoDestTypeFieldInfo = "type" + type AttrOrigin ActionGotoDestTypeFieldInfo = ActionGotoDest + attrGet _ = getActionGotoDestType + attrSet _ = setActionGotoDestType + attrConstruct = undefined + attrClear _ = undefined + +actionGotoDest_type :: AttrLabelProxy "type" +actionGotoDest_type = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@title@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' actionGotoDest #title +@ +-} +getActionGotoDestTitle :: MonadIO m => ActionGotoDest -> m (Maybe T.Text) +getActionGotoDestTitle s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 8) :: IO CString + result <- SP.convertIfNonNull val $ \val' -> do + val'' <- cstringToText val' + return val'' + return result + +{- | +Set the value of the “@title@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' actionGotoDest [ #title 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setActionGotoDestTitle :: MonadIO m => ActionGotoDest -> CString -> m () +setActionGotoDestTitle s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 8) (val :: CString) + +{- | +Set the value of the “@title@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #title +@ +-} +clearActionGotoDestTitle :: MonadIO m => ActionGotoDest -> m () +clearActionGotoDestTitle s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 8) (FP.nullPtr :: CString) + +#if ENABLE_OVERLOADING +data ActionGotoDestTitleFieldInfo +instance AttrInfo ActionGotoDestTitleFieldInfo where + type AttrAllowedOps ActionGotoDestTitleFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint ActionGotoDestTitleFieldInfo = (~) CString + type AttrBaseTypeConstraint ActionGotoDestTitleFieldInfo = (~) ActionGotoDest + type AttrGetType ActionGotoDestTitleFieldInfo = Maybe T.Text + type AttrLabel ActionGotoDestTitleFieldInfo = "title" + type AttrOrigin ActionGotoDestTitleFieldInfo = ActionGotoDest + attrGet _ = getActionGotoDestTitle + attrSet _ = setActionGotoDestTitle + attrConstruct = undefined + attrClear _ = clearActionGotoDestTitle + +actionGotoDest_title :: AttrLabelProxy "title" +actionGotoDest_title = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@dest@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' actionGotoDest #dest +@ +-} +getActionGotoDestDest :: MonadIO m => ActionGotoDest -> m (Maybe Poppler.Dest.Dest) +getActionGotoDestDest s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 16) :: IO (Ptr Poppler.Dest.Dest) + result <- SP.convertIfNonNull val $ \val' -> do + val'' <- (newBoxed Poppler.Dest.Dest) val' + return val'' + return result + +{- | +Set the value of the “@dest@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' actionGotoDest [ #dest 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setActionGotoDestDest :: MonadIO m => ActionGotoDest -> Ptr Poppler.Dest.Dest -> m () +setActionGotoDestDest s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 16) (val :: Ptr Poppler.Dest.Dest) + +{- | +Set the value of the “@dest@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #dest +@ +-} +clearActionGotoDestDest :: MonadIO m => ActionGotoDest -> m () +clearActionGotoDestDest s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 16) (FP.nullPtr :: Ptr Poppler.Dest.Dest) + +#if ENABLE_OVERLOADING +data ActionGotoDestDestFieldInfo +instance AttrInfo ActionGotoDestDestFieldInfo where + type AttrAllowedOps ActionGotoDestDestFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint ActionGotoDestDestFieldInfo = (~) (Ptr Poppler.Dest.Dest) + type AttrBaseTypeConstraint ActionGotoDestDestFieldInfo = (~) ActionGotoDest + type AttrGetType ActionGotoDestDestFieldInfo = Maybe Poppler.Dest.Dest + type AttrLabel ActionGotoDestDestFieldInfo = "dest" + type AttrOrigin ActionGotoDestDestFieldInfo = ActionGotoDest + attrGet _ = getActionGotoDestDest + attrSet _ = setActionGotoDestDest + attrConstruct = undefined + attrClear _ = clearActionGotoDestDest + +actionGotoDest_dest :: AttrLabelProxy "dest" +actionGotoDest_dest = AttrLabelProxy + +#endif + + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList ActionGotoDest +type instance O.AttributeList ActionGotoDest = ActionGotoDestAttributeList +type ActionGotoDestAttributeList = ('[ '("type", ActionGotoDestTypeFieldInfo), '("title", ActionGotoDestTitleFieldInfo), '("dest", ActionGotoDestDestFieldInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +type family ResolveActionGotoDestMethod (t :: Symbol) (o :: *) :: * where + ResolveActionGotoDestMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveActionGotoDestMethod t ActionGotoDest, O.MethodInfo info ActionGotoDest p) => OL.IsLabel t (ActionGotoDest -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + 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,26 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Poppler.Structs.ActionGotoDest where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype ActionGotoDest = ActionGotoDest (ManagedPtr ActionGotoDest) +instance WrappedPtr ActionGotoDest where 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,363 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Poppler.Structs.ActionGotoRemote + ( + +-- * Exported types + ActionGotoRemote(..) , + newZeroActionGotoRemote , + noActionGotoRemote , + + + -- * Properties +-- ** dest #attr:dest# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + actionGotoRemote_dest , +#endif + clearActionGotoRemoteDest , + getActionGotoRemoteDest , + setActionGotoRemoteDest , + + +-- ** fileName #attr:fileName# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + actionGotoRemote_fileName , +#endif + clearActionGotoRemoteFileName , + getActionGotoRemoteFileName , + setActionGotoRemoteFileName , + + +-- ** title #attr:title# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + actionGotoRemote_title , +#endif + clearActionGotoRemoteTitle , + getActionGotoRemoteTitle , + setActionGotoRemoteTitle , + + +-- ** type #attr:type# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + actionGotoRemote_type , +#endif + getActionGotoRemoteType , + setActionGotoRemoteType , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import {-# SOURCE #-} qualified GI.Poppler.Enums as Poppler.Enums +import {-# SOURCE #-} qualified GI.Poppler.Structs.Dest as Poppler.Dest + +-- | Memory-managed wrapper type. +newtype ActionGotoRemote = ActionGotoRemote (ManagedPtr ActionGotoRemote) +instance WrappedPtr ActionGotoRemote where + wrappedPtrCalloc = callocBytes 32 + wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 32 >=> wrapPtr ActionGotoRemote) + wrappedPtrFree = Just ptr_to_g_free + +-- | Construct a `ActionGotoRemote` struct initialized to zero. +newZeroActionGotoRemote :: MonadIO m => m ActionGotoRemote +newZeroActionGotoRemote = liftIO $ wrappedPtrCalloc >>= wrapPtr ActionGotoRemote + +instance tag ~ 'AttrSet => Constructible ActionGotoRemote tag where + new _ attrs = do + o <- newZeroActionGotoRemote + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `ActionGotoRemote`. +noActionGotoRemote :: Maybe ActionGotoRemote +noActionGotoRemote = Nothing + +{- | +Get the value of the “@type@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' actionGotoRemote #type +@ +-} +getActionGotoRemoteType :: MonadIO m => ActionGotoRemote -> m Poppler.Enums.ActionType +getActionGotoRemoteType s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO CUInt + let val' = (toEnum . fromIntegral) val + return val' + +{- | +Set the value of the “@type@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' actionGotoRemote [ #type 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setActionGotoRemoteType :: MonadIO m => ActionGotoRemote -> Poppler.Enums.ActionType -> m () +setActionGotoRemoteType s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = (fromIntegral . fromEnum) val + poke (ptr `plusPtr` 0) (val' :: CUInt) + +#if ENABLE_OVERLOADING +data ActionGotoRemoteTypeFieldInfo +instance AttrInfo ActionGotoRemoteTypeFieldInfo where + type AttrAllowedOps ActionGotoRemoteTypeFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint ActionGotoRemoteTypeFieldInfo = (~) Poppler.Enums.ActionType + type AttrBaseTypeConstraint ActionGotoRemoteTypeFieldInfo = (~) ActionGotoRemote + type AttrGetType ActionGotoRemoteTypeFieldInfo = Poppler.Enums.ActionType + type AttrLabel ActionGotoRemoteTypeFieldInfo = "type" + type AttrOrigin ActionGotoRemoteTypeFieldInfo = ActionGotoRemote + attrGet _ = getActionGotoRemoteType + attrSet _ = setActionGotoRemoteType + attrConstruct = undefined + attrClear _ = undefined + +actionGotoRemote_type :: AttrLabelProxy "type" +actionGotoRemote_type = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@title@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' actionGotoRemote #title +@ +-} +getActionGotoRemoteTitle :: MonadIO m => ActionGotoRemote -> m (Maybe T.Text) +getActionGotoRemoteTitle s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 8) :: IO CString + result <- SP.convertIfNonNull val $ \val' -> do + val'' <- cstringToText val' + return val'' + return result + +{- | +Set the value of the “@title@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' actionGotoRemote [ #title 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setActionGotoRemoteTitle :: MonadIO m => ActionGotoRemote -> CString -> m () +setActionGotoRemoteTitle s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 8) (val :: CString) + +{- | +Set the value of the “@title@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #title +@ +-} +clearActionGotoRemoteTitle :: MonadIO m => ActionGotoRemote -> m () +clearActionGotoRemoteTitle s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 8) (FP.nullPtr :: CString) + +#if ENABLE_OVERLOADING +data ActionGotoRemoteTitleFieldInfo +instance AttrInfo ActionGotoRemoteTitleFieldInfo where + type AttrAllowedOps ActionGotoRemoteTitleFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint ActionGotoRemoteTitleFieldInfo = (~) CString + type AttrBaseTypeConstraint ActionGotoRemoteTitleFieldInfo = (~) ActionGotoRemote + type AttrGetType ActionGotoRemoteTitleFieldInfo = Maybe T.Text + type AttrLabel ActionGotoRemoteTitleFieldInfo = "title" + type AttrOrigin ActionGotoRemoteTitleFieldInfo = ActionGotoRemote + attrGet _ = getActionGotoRemoteTitle + attrSet _ = setActionGotoRemoteTitle + attrConstruct = undefined + attrClear _ = clearActionGotoRemoteTitle + +actionGotoRemote_title :: AttrLabelProxy "title" +actionGotoRemote_title = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@file_name@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' actionGotoRemote #fileName +@ +-} +getActionGotoRemoteFileName :: MonadIO m => ActionGotoRemote -> m (Maybe T.Text) +getActionGotoRemoteFileName s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 16) :: IO CString + result <- SP.convertIfNonNull val $ \val' -> do + val'' <- cstringToText val' + return val'' + return result + +{- | +Set the value of the “@file_name@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' actionGotoRemote [ #fileName 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setActionGotoRemoteFileName :: MonadIO m => ActionGotoRemote -> CString -> m () +setActionGotoRemoteFileName s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 16) (val :: CString) + +{- | +Set the value of the “@file_name@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #fileName +@ +-} +clearActionGotoRemoteFileName :: MonadIO m => ActionGotoRemote -> m () +clearActionGotoRemoteFileName s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 16) (FP.nullPtr :: CString) + +#if ENABLE_OVERLOADING +data ActionGotoRemoteFileNameFieldInfo +instance AttrInfo ActionGotoRemoteFileNameFieldInfo where + type AttrAllowedOps ActionGotoRemoteFileNameFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint ActionGotoRemoteFileNameFieldInfo = (~) CString + type AttrBaseTypeConstraint ActionGotoRemoteFileNameFieldInfo = (~) ActionGotoRemote + type AttrGetType ActionGotoRemoteFileNameFieldInfo = Maybe T.Text + type AttrLabel ActionGotoRemoteFileNameFieldInfo = "file_name" + type AttrOrigin ActionGotoRemoteFileNameFieldInfo = ActionGotoRemote + attrGet _ = getActionGotoRemoteFileName + attrSet _ = setActionGotoRemoteFileName + attrConstruct = undefined + attrClear _ = clearActionGotoRemoteFileName + +actionGotoRemote_fileName :: AttrLabelProxy "fileName" +actionGotoRemote_fileName = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@dest@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' actionGotoRemote #dest +@ +-} +getActionGotoRemoteDest :: MonadIO m => ActionGotoRemote -> m (Maybe Poppler.Dest.Dest) +getActionGotoRemoteDest s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 24) :: IO (Ptr Poppler.Dest.Dest) + result <- SP.convertIfNonNull val $ \val' -> do + val'' <- (newBoxed Poppler.Dest.Dest) val' + return val'' + return result + +{- | +Set the value of the “@dest@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' actionGotoRemote [ #dest 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setActionGotoRemoteDest :: MonadIO m => ActionGotoRemote -> Ptr Poppler.Dest.Dest -> m () +setActionGotoRemoteDest s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 24) (val :: Ptr Poppler.Dest.Dest) + +{- | +Set the value of the “@dest@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #dest +@ +-} +clearActionGotoRemoteDest :: MonadIO m => ActionGotoRemote -> m () +clearActionGotoRemoteDest s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 24) (FP.nullPtr :: Ptr Poppler.Dest.Dest) + +#if ENABLE_OVERLOADING +data ActionGotoRemoteDestFieldInfo +instance AttrInfo ActionGotoRemoteDestFieldInfo where + type AttrAllowedOps ActionGotoRemoteDestFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint ActionGotoRemoteDestFieldInfo = (~) (Ptr Poppler.Dest.Dest) + type AttrBaseTypeConstraint ActionGotoRemoteDestFieldInfo = (~) ActionGotoRemote + type AttrGetType ActionGotoRemoteDestFieldInfo = Maybe Poppler.Dest.Dest + type AttrLabel ActionGotoRemoteDestFieldInfo = "dest" + type AttrOrigin ActionGotoRemoteDestFieldInfo = ActionGotoRemote + attrGet _ = getActionGotoRemoteDest + attrSet _ = setActionGotoRemoteDest + attrConstruct = undefined + attrClear _ = clearActionGotoRemoteDest + +actionGotoRemote_dest :: AttrLabelProxy "dest" +actionGotoRemote_dest = AttrLabelProxy + +#endif + + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList ActionGotoRemote +type instance O.AttributeList ActionGotoRemote = ActionGotoRemoteAttributeList +type ActionGotoRemoteAttributeList = ('[ '("type", ActionGotoRemoteTypeFieldInfo), '("title", ActionGotoRemoteTitleFieldInfo), '("fileName", ActionGotoRemoteFileNameFieldInfo), '("dest", ActionGotoRemoteDestFieldInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +type family ResolveActionGotoRemoteMethod (t :: Symbol) (o :: *) :: * where + ResolveActionGotoRemoteMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveActionGotoRemoteMethod t ActionGotoRemote, O.MethodInfo info ActionGotoRemote p) => OL.IsLabel t (ActionGotoRemote -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + 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,26 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Poppler.Structs.ActionGotoRemote where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype ActionGotoRemote = ActionGotoRemote (ManagedPtr ActionGotoRemote) +instance WrappedPtr ActionGotoRemote where 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,291 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Poppler.Structs.ActionJavascript + ( + +-- * Exported types + ActionJavascript(..) , + newZeroActionJavascript , + noActionJavascript , + + + -- * Properties +-- ** script #attr:script# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + actionJavascript_script , +#endif + clearActionJavascriptScript , + getActionJavascriptScript , + setActionJavascriptScript , + + +-- ** title #attr:title# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + actionJavascript_title , +#endif + clearActionJavascriptTitle , + getActionJavascriptTitle , + setActionJavascriptTitle , + + +-- ** type #attr:type# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + actionJavascript_type , +#endif + getActionJavascriptType , + setActionJavascriptType , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import {-# SOURCE #-} qualified GI.Poppler.Enums as Poppler.Enums + +-- | Memory-managed wrapper type. +newtype ActionJavascript = ActionJavascript (ManagedPtr ActionJavascript) +instance WrappedPtr ActionJavascript where + wrappedPtrCalloc = callocBytes 24 + wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 24 >=> wrapPtr ActionJavascript) + wrappedPtrFree = Just ptr_to_g_free + +-- | Construct a `ActionJavascript` struct initialized to zero. +newZeroActionJavascript :: MonadIO m => m ActionJavascript +newZeroActionJavascript = liftIO $ wrappedPtrCalloc >>= wrapPtr ActionJavascript + +instance tag ~ 'AttrSet => Constructible ActionJavascript tag where + new _ attrs = do + o <- newZeroActionJavascript + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `ActionJavascript`. +noActionJavascript :: Maybe ActionJavascript +noActionJavascript = Nothing + +{- | +Get the value of the “@type@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' actionJavascript #type +@ +-} +getActionJavascriptType :: MonadIO m => ActionJavascript -> m Poppler.Enums.ActionType +getActionJavascriptType s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO CUInt + let val' = (toEnum . fromIntegral) val + return val' + +{- | +Set the value of the “@type@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' actionJavascript [ #type 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setActionJavascriptType :: MonadIO m => ActionJavascript -> Poppler.Enums.ActionType -> m () +setActionJavascriptType s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = (fromIntegral . fromEnum) val + poke (ptr `plusPtr` 0) (val' :: CUInt) + +#if ENABLE_OVERLOADING +data ActionJavascriptTypeFieldInfo +instance AttrInfo ActionJavascriptTypeFieldInfo where + type AttrAllowedOps ActionJavascriptTypeFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint ActionJavascriptTypeFieldInfo = (~) Poppler.Enums.ActionType + type AttrBaseTypeConstraint ActionJavascriptTypeFieldInfo = (~) ActionJavascript + type AttrGetType ActionJavascriptTypeFieldInfo = Poppler.Enums.ActionType + type AttrLabel ActionJavascriptTypeFieldInfo = "type" + type AttrOrigin ActionJavascriptTypeFieldInfo = ActionJavascript + attrGet _ = getActionJavascriptType + attrSet _ = setActionJavascriptType + attrConstruct = undefined + attrClear _ = undefined + +actionJavascript_type :: AttrLabelProxy "type" +actionJavascript_type = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@title@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' actionJavascript #title +@ +-} +getActionJavascriptTitle :: MonadIO m => ActionJavascript -> m (Maybe T.Text) +getActionJavascriptTitle s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 8) :: IO CString + result <- SP.convertIfNonNull val $ \val' -> do + val'' <- cstringToText val' + return val'' + return result + +{- | +Set the value of the “@title@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' actionJavascript [ #title 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setActionJavascriptTitle :: MonadIO m => ActionJavascript -> CString -> m () +setActionJavascriptTitle s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 8) (val :: CString) + +{- | +Set the value of the “@title@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #title +@ +-} +clearActionJavascriptTitle :: MonadIO m => ActionJavascript -> m () +clearActionJavascriptTitle s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 8) (FP.nullPtr :: CString) + +#if ENABLE_OVERLOADING +data ActionJavascriptTitleFieldInfo +instance AttrInfo ActionJavascriptTitleFieldInfo where + type AttrAllowedOps ActionJavascriptTitleFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint ActionJavascriptTitleFieldInfo = (~) CString + type AttrBaseTypeConstraint ActionJavascriptTitleFieldInfo = (~) ActionJavascript + type AttrGetType ActionJavascriptTitleFieldInfo = Maybe T.Text + type AttrLabel ActionJavascriptTitleFieldInfo = "title" + type AttrOrigin ActionJavascriptTitleFieldInfo = ActionJavascript + attrGet _ = getActionJavascriptTitle + attrSet _ = setActionJavascriptTitle + attrConstruct = undefined + attrClear _ = clearActionJavascriptTitle + +actionJavascript_title :: AttrLabelProxy "title" +actionJavascript_title = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@script@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' actionJavascript #script +@ +-} +getActionJavascriptScript :: MonadIO m => ActionJavascript -> m (Maybe T.Text) +getActionJavascriptScript s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 16) :: IO CString + result <- SP.convertIfNonNull val $ \val' -> do + val'' <- cstringToText val' + return val'' + return result + +{- | +Set the value of the “@script@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' actionJavascript [ #script 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setActionJavascriptScript :: MonadIO m => ActionJavascript -> CString -> m () +setActionJavascriptScript s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 16) (val :: CString) + +{- | +Set the value of the “@script@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #script +@ +-} +clearActionJavascriptScript :: MonadIO m => ActionJavascript -> m () +clearActionJavascriptScript s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 16) (FP.nullPtr :: CString) + +#if ENABLE_OVERLOADING +data ActionJavascriptScriptFieldInfo +instance AttrInfo ActionJavascriptScriptFieldInfo where + type AttrAllowedOps ActionJavascriptScriptFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint ActionJavascriptScriptFieldInfo = (~) CString + type AttrBaseTypeConstraint ActionJavascriptScriptFieldInfo = (~) ActionJavascript + type AttrGetType ActionJavascriptScriptFieldInfo = Maybe T.Text + type AttrLabel ActionJavascriptScriptFieldInfo = "script" + type AttrOrigin ActionJavascriptScriptFieldInfo = ActionJavascript + attrGet _ = getActionJavascriptScript + attrSet _ = setActionJavascriptScript + attrConstruct = undefined + attrClear _ = clearActionJavascriptScript + +actionJavascript_script :: AttrLabelProxy "script" +actionJavascript_script = AttrLabelProxy + +#endif + + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList ActionJavascript +type instance O.AttributeList ActionJavascript = ActionJavascriptAttributeList +type ActionJavascriptAttributeList = ('[ '("type", ActionJavascriptTypeFieldInfo), '("title", ActionJavascriptTitleFieldInfo), '("script", ActionJavascriptScriptFieldInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +type family ResolveActionJavascriptMethod (t :: Symbol) (o :: *) :: * where + ResolveActionJavascriptMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveActionJavascriptMethod t ActionJavascript, O.MethodInfo info ActionJavascript p) => OL.IsLabel t (ActionJavascript -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + 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,26 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Poppler.Structs.ActionJavascript where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype ActionJavascript = ActionJavascript (ManagedPtr ActionJavascript) +instance WrappedPtr ActionJavascript where 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,362 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Poppler.Structs.ActionLaunch + ( + +-- * Exported types + ActionLaunch(..) , + newZeroActionLaunch , + noActionLaunch , + + + -- * Properties +-- ** fileName #attr:fileName# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + actionLaunch_fileName , +#endif + clearActionLaunchFileName , + getActionLaunchFileName , + setActionLaunchFileName , + + +-- ** params #attr:params# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + actionLaunch_params , +#endif + clearActionLaunchParams , + getActionLaunchParams , + setActionLaunchParams , + + +-- ** title #attr:title# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + actionLaunch_title , +#endif + clearActionLaunchTitle , + getActionLaunchTitle , + setActionLaunchTitle , + + +-- ** type #attr:type# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + actionLaunch_type , +#endif + getActionLaunchType , + setActionLaunchType , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import {-# SOURCE #-} qualified GI.Poppler.Enums as Poppler.Enums + +-- | Memory-managed wrapper type. +newtype ActionLaunch = ActionLaunch (ManagedPtr ActionLaunch) +instance WrappedPtr ActionLaunch where + wrappedPtrCalloc = callocBytes 32 + wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 32 >=> wrapPtr ActionLaunch) + wrappedPtrFree = Just ptr_to_g_free + +-- | Construct a `ActionLaunch` struct initialized to zero. +newZeroActionLaunch :: MonadIO m => m ActionLaunch +newZeroActionLaunch = liftIO $ wrappedPtrCalloc >>= wrapPtr ActionLaunch + +instance tag ~ 'AttrSet => Constructible ActionLaunch tag where + new _ attrs = do + o <- newZeroActionLaunch + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `ActionLaunch`. +noActionLaunch :: Maybe ActionLaunch +noActionLaunch = Nothing + +{- | +Get the value of the “@type@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' actionLaunch #type +@ +-} +getActionLaunchType :: MonadIO m => ActionLaunch -> m Poppler.Enums.ActionType +getActionLaunchType s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO CUInt + let val' = (toEnum . fromIntegral) val + return val' + +{- | +Set the value of the “@type@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' actionLaunch [ #type 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setActionLaunchType :: MonadIO m => ActionLaunch -> Poppler.Enums.ActionType -> m () +setActionLaunchType s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = (fromIntegral . fromEnum) val + poke (ptr `plusPtr` 0) (val' :: CUInt) + +#if ENABLE_OVERLOADING +data ActionLaunchTypeFieldInfo +instance AttrInfo ActionLaunchTypeFieldInfo where + type AttrAllowedOps ActionLaunchTypeFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint ActionLaunchTypeFieldInfo = (~) Poppler.Enums.ActionType + type AttrBaseTypeConstraint ActionLaunchTypeFieldInfo = (~) ActionLaunch + type AttrGetType ActionLaunchTypeFieldInfo = Poppler.Enums.ActionType + type AttrLabel ActionLaunchTypeFieldInfo = "type" + type AttrOrigin ActionLaunchTypeFieldInfo = ActionLaunch + attrGet _ = getActionLaunchType + attrSet _ = setActionLaunchType + attrConstruct = undefined + attrClear _ = undefined + +actionLaunch_type :: AttrLabelProxy "type" +actionLaunch_type = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@title@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' actionLaunch #title +@ +-} +getActionLaunchTitle :: MonadIO m => ActionLaunch -> m (Maybe T.Text) +getActionLaunchTitle s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 8) :: IO CString + result <- SP.convertIfNonNull val $ \val' -> do + val'' <- cstringToText val' + return val'' + return result + +{- | +Set the value of the “@title@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' actionLaunch [ #title 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setActionLaunchTitle :: MonadIO m => ActionLaunch -> CString -> m () +setActionLaunchTitle s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 8) (val :: CString) + +{- | +Set the value of the “@title@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #title +@ +-} +clearActionLaunchTitle :: MonadIO m => ActionLaunch -> m () +clearActionLaunchTitle s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 8) (FP.nullPtr :: CString) + +#if ENABLE_OVERLOADING +data ActionLaunchTitleFieldInfo +instance AttrInfo ActionLaunchTitleFieldInfo where + type AttrAllowedOps ActionLaunchTitleFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint ActionLaunchTitleFieldInfo = (~) CString + type AttrBaseTypeConstraint ActionLaunchTitleFieldInfo = (~) ActionLaunch + type AttrGetType ActionLaunchTitleFieldInfo = Maybe T.Text + type AttrLabel ActionLaunchTitleFieldInfo = "title" + type AttrOrigin ActionLaunchTitleFieldInfo = ActionLaunch + attrGet _ = getActionLaunchTitle + attrSet _ = setActionLaunchTitle + attrConstruct = undefined + attrClear _ = clearActionLaunchTitle + +actionLaunch_title :: AttrLabelProxy "title" +actionLaunch_title = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@file_name@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' actionLaunch #fileName +@ +-} +getActionLaunchFileName :: MonadIO m => ActionLaunch -> m (Maybe T.Text) +getActionLaunchFileName s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 16) :: IO CString + result <- SP.convertIfNonNull val $ \val' -> do + val'' <- cstringToText val' + return val'' + return result + +{- | +Set the value of the “@file_name@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' actionLaunch [ #fileName 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setActionLaunchFileName :: MonadIO m => ActionLaunch -> CString -> m () +setActionLaunchFileName s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 16) (val :: CString) + +{- | +Set the value of the “@file_name@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #fileName +@ +-} +clearActionLaunchFileName :: MonadIO m => ActionLaunch -> m () +clearActionLaunchFileName s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 16) (FP.nullPtr :: CString) + +#if ENABLE_OVERLOADING +data ActionLaunchFileNameFieldInfo +instance AttrInfo ActionLaunchFileNameFieldInfo where + type AttrAllowedOps ActionLaunchFileNameFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint ActionLaunchFileNameFieldInfo = (~) CString + type AttrBaseTypeConstraint ActionLaunchFileNameFieldInfo = (~) ActionLaunch + type AttrGetType ActionLaunchFileNameFieldInfo = Maybe T.Text + type AttrLabel ActionLaunchFileNameFieldInfo = "file_name" + type AttrOrigin ActionLaunchFileNameFieldInfo = ActionLaunch + attrGet _ = getActionLaunchFileName + attrSet _ = setActionLaunchFileName + attrConstruct = undefined + attrClear _ = clearActionLaunchFileName + +actionLaunch_fileName :: AttrLabelProxy "fileName" +actionLaunch_fileName = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@params@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' actionLaunch #params +@ +-} +getActionLaunchParams :: MonadIO m => ActionLaunch -> m (Maybe T.Text) +getActionLaunchParams s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 24) :: IO CString + result <- SP.convertIfNonNull val $ \val' -> do + val'' <- cstringToText val' + return val'' + return result + +{- | +Set the value of the “@params@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' actionLaunch [ #params 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setActionLaunchParams :: MonadIO m => ActionLaunch -> CString -> m () +setActionLaunchParams s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 24) (val :: CString) + +{- | +Set the value of the “@params@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #params +@ +-} +clearActionLaunchParams :: MonadIO m => ActionLaunch -> m () +clearActionLaunchParams s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 24) (FP.nullPtr :: CString) + +#if ENABLE_OVERLOADING +data ActionLaunchParamsFieldInfo +instance AttrInfo ActionLaunchParamsFieldInfo where + type AttrAllowedOps ActionLaunchParamsFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint ActionLaunchParamsFieldInfo = (~) CString + type AttrBaseTypeConstraint ActionLaunchParamsFieldInfo = (~) ActionLaunch + type AttrGetType ActionLaunchParamsFieldInfo = Maybe T.Text + type AttrLabel ActionLaunchParamsFieldInfo = "params" + type AttrOrigin ActionLaunchParamsFieldInfo = ActionLaunch + attrGet _ = getActionLaunchParams + attrSet _ = setActionLaunchParams + attrConstruct = undefined + attrClear _ = clearActionLaunchParams + +actionLaunch_params :: AttrLabelProxy "params" +actionLaunch_params = AttrLabelProxy + +#endif + + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList ActionLaunch +type instance O.AttributeList ActionLaunch = ActionLaunchAttributeList +type ActionLaunchAttributeList = ('[ '("type", ActionLaunchTypeFieldInfo), '("title", ActionLaunchTitleFieldInfo), '("fileName", ActionLaunchFileNameFieldInfo), '("params", ActionLaunchParamsFieldInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +type family ResolveActionLaunchMethod (t :: Symbol) (o :: *) :: * where + ResolveActionLaunchMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveActionLaunchMethod t ActionLaunch, O.MethodInfo info ActionLaunch p) => OL.IsLabel t (ActionLaunch -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + 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,26 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Poppler.Structs.ActionLaunch where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype ActionLaunch = ActionLaunch (ManagedPtr ActionLaunch) +instance WrappedPtr ActionLaunch where 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,218 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Action to perform over a list of layers +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Poppler.Structs.ActionLayer + ( + +-- * Exported types + ActionLayer(..) , + newZeroActionLayer , + noActionLayer , + + + -- * Properties +-- ** action #attr:action# +{- | a 'GI.Poppler.Enums.ActionLayerAction' +-} +#if ENABLE_OVERLOADING + actionLayer_action , +#endif + getActionLayerAction , + setActionLayerAction , + + +-- ** layers #attr:layers# +{- | list of 'GI.Poppler.Objects.Layer.Layer'\s +-} +#if ENABLE_OVERLOADING + actionLayer_layers , +#endif + clearActionLayerLayers , + getActionLayerLayers , + setActionLayerLayers , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import {-# SOURCE #-} qualified GI.Poppler.Enums as Poppler.Enums + +-- | Memory-managed wrapper type. +newtype ActionLayer = ActionLayer (ManagedPtr ActionLayer) +instance WrappedPtr ActionLayer where + wrappedPtrCalloc = callocBytes 16 + wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 16 >=> wrapPtr ActionLayer) + wrappedPtrFree = Just ptr_to_g_free + +-- | Construct a `ActionLayer` struct initialized to zero. +newZeroActionLayer :: MonadIO m => m ActionLayer +newZeroActionLayer = liftIO $ wrappedPtrCalloc >>= wrapPtr ActionLayer + +instance tag ~ 'AttrSet => Constructible ActionLayer tag where + new _ attrs = do + o <- newZeroActionLayer + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `ActionLayer`. +noActionLayer :: Maybe ActionLayer +noActionLayer = Nothing + +{- | +Get the value of the “@action@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' actionLayer #action +@ +-} +getActionLayerAction :: MonadIO m => ActionLayer -> m Poppler.Enums.ActionLayerAction +getActionLayerAction s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO CUInt + let val' = (toEnum . fromIntegral) val + return val' + +{- | +Set the value of the “@action@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' actionLayer [ #action 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setActionLayerAction :: MonadIO m => ActionLayer -> Poppler.Enums.ActionLayerAction -> m () +setActionLayerAction s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = (fromIntegral . fromEnum) val + poke (ptr `plusPtr` 0) (val' :: CUInt) + +#if ENABLE_OVERLOADING +data ActionLayerActionFieldInfo +instance AttrInfo ActionLayerActionFieldInfo where + type AttrAllowedOps ActionLayerActionFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint ActionLayerActionFieldInfo = (~) Poppler.Enums.ActionLayerAction + type AttrBaseTypeConstraint ActionLayerActionFieldInfo = (~) ActionLayer + type AttrGetType ActionLayerActionFieldInfo = Poppler.Enums.ActionLayerAction + type AttrLabel ActionLayerActionFieldInfo = "action" + type AttrOrigin ActionLayerActionFieldInfo = ActionLayer + attrGet _ = getActionLayerAction + attrSet _ = setActionLayerAction + attrConstruct = undefined + attrClear _ = undefined + +actionLayer_action :: AttrLabelProxy "action" +actionLayer_action = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@layers@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' actionLayer #layers +@ +-} +getActionLayerLayers :: MonadIO m => ActionLayer -> m ([Ptr ()]) +getActionLayerLayers s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 8) :: IO (Ptr (GList (Ptr ()))) + val' <- unpackGList val + return val' + +{- | +Set the value of the “@layers@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' actionLayer [ #layers 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setActionLayerLayers :: MonadIO m => ActionLayer -> Ptr (GList (Ptr ())) -> m () +setActionLayerLayers s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 8) (val :: Ptr (GList (Ptr ()))) + +{- | +Set the value of the “@layers@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #layers +@ +-} +clearActionLayerLayers :: MonadIO m => ActionLayer -> m () +clearActionLayerLayers s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 8) (FP.nullPtr :: Ptr (GList (Ptr ()))) + +#if ENABLE_OVERLOADING +data ActionLayerLayersFieldInfo +instance AttrInfo ActionLayerLayersFieldInfo where + type AttrAllowedOps ActionLayerLayersFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint ActionLayerLayersFieldInfo = (~) (Ptr (GList (Ptr ()))) + type AttrBaseTypeConstraint ActionLayerLayersFieldInfo = (~) ActionLayer + type AttrGetType ActionLayerLayersFieldInfo = [Ptr ()] + type AttrLabel ActionLayerLayersFieldInfo = "layers" + type AttrOrigin ActionLayerLayersFieldInfo = ActionLayer + attrGet _ = getActionLayerLayers + attrSet _ = setActionLayerLayers + attrConstruct = undefined + attrClear _ = clearActionLayerLayers + +actionLayer_layers :: AttrLabelProxy "layers" +actionLayer_layers = AttrLabelProxy + +#endif + + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList ActionLayer +type instance O.AttributeList ActionLayer = ActionLayerAttributeList +type ActionLayerAttributeList = ('[ '("action", ActionLayerActionFieldInfo), '("layers", ActionLayerLayersFieldInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +type family ResolveActionLayerMethod (t :: Symbol) (o :: *) :: * where + ResolveActionLayerMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveActionLayerMethod t ActionLayer, O.MethodInfo info ActionLayer p) => OL.IsLabel t (ActionLayer -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + 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,26 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Poppler.Structs.ActionLayer where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype ActionLayer = ActionLayer (ManagedPtr ActionLayer) +instance WrappedPtr ActionLayer where 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,349 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Poppler.Structs.ActionMovie + ( + +-- * Exported types + ActionMovie(..) , + newZeroActionMovie , + noActionMovie , + + + -- * Properties +-- ** movie #attr:movie# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + actionMovie_movie , +#endif + clearActionMovieMovie , + getActionMovieMovie , + setActionMovieMovie , + + +-- ** operation #attr:operation# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + actionMovie_operation , +#endif + getActionMovieOperation , + setActionMovieOperation , + + +-- ** title #attr:title# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + actionMovie_title , +#endif + clearActionMovieTitle , + getActionMovieTitle , + setActionMovieTitle , + + +-- ** type #attr:type# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + actionMovie_type , +#endif + getActionMovieType , + setActionMovieType , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import {-# SOURCE #-} qualified GI.Poppler.Enums as Poppler.Enums +import {-# SOURCE #-} qualified GI.Poppler.Objects.Movie as Poppler.Movie + +-- | Memory-managed wrapper type. +newtype ActionMovie = ActionMovie (ManagedPtr ActionMovie) +instance WrappedPtr ActionMovie where + wrappedPtrCalloc = callocBytes 32 + wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 32 >=> wrapPtr ActionMovie) + wrappedPtrFree = Just ptr_to_g_free + +-- | Construct a `ActionMovie` struct initialized to zero. +newZeroActionMovie :: MonadIO m => m ActionMovie +newZeroActionMovie = liftIO $ wrappedPtrCalloc >>= wrapPtr ActionMovie + +instance tag ~ 'AttrSet => Constructible ActionMovie tag where + new _ attrs = do + o <- newZeroActionMovie + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `ActionMovie`. +noActionMovie :: Maybe ActionMovie +noActionMovie = Nothing + +{- | +Get the value of the “@type@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' actionMovie #type +@ +-} +getActionMovieType :: MonadIO m => ActionMovie -> m Poppler.Enums.ActionType +getActionMovieType s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO CUInt + let val' = (toEnum . fromIntegral) val + return val' + +{- | +Set the value of the “@type@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' actionMovie [ #type 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setActionMovieType :: MonadIO m => ActionMovie -> Poppler.Enums.ActionType -> m () +setActionMovieType s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = (fromIntegral . fromEnum) val + poke (ptr `plusPtr` 0) (val' :: CUInt) + +#if ENABLE_OVERLOADING +data ActionMovieTypeFieldInfo +instance AttrInfo ActionMovieTypeFieldInfo where + type AttrAllowedOps ActionMovieTypeFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint ActionMovieTypeFieldInfo = (~) Poppler.Enums.ActionType + type AttrBaseTypeConstraint ActionMovieTypeFieldInfo = (~) ActionMovie + type AttrGetType ActionMovieTypeFieldInfo = Poppler.Enums.ActionType + type AttrLabel ActionMovieTypeFieldInfo = "type" + type AttrOrigin ActionMovieTypeFieldInfo = ActionMovie + attrGet _ = getActionMovieType + attrSet _ = setActionMovieType + attrConstruct = undefined + attrClear _ = undefined + +actionMovie_type :: AttrLabelProxy "type" +actionMovie_type = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@title@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' actionMovie #title +@ +-} +getActionMovieTitle :: MonadIO m => ActionMovie -> m (Maybe T.Text) +getActionMovieTitle s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 8) :: IO CString + result <- SP.convertIfNonNull val $ \val' -> do + val'' <- cstringToText val' + return val'' + return result + +{- | +Set the value of the “@title@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' actionMovie [ #title 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setActionMovieTitle :: MonadIO m => ActionMovie -> CString -> m () +setActionMovieTitle s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 8) (val :: CString) + +{- | +Set the value of the “@title@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #title +@ +-} +clearActionMovieTitle :: MonadIO m => ActionMovie -> m () +clearActionMovieTitle s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 8) (FP.nullPtr :: CString) + +#if ENABLE_OVERLOADING +data ActionMovieTitleFieldInfo +instance AttrInfo ActionMovieTitleFieldInfo where + type AttrAllowedOps ActionMovieTitleFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint ActionMovieTitleFieldInfo = (~) CString + type AttrBaseTypeConstraint ActionMovieTitleFieldInfo = (~) ActionMovie + type AttrGetType ActionMovieTitleFieldInfo = Maybe T.Text + type AttrLabel ActionMovieTitleFieldInfo = "title" + type AttrOrigin ActionMovieTitleFieldInfo = ActionMovie + attrGet _ = getActionMovieTitle + attrSet _ = setActionMovieTitle + attrConstruct = undefined + attrClear _ = clearActionMovieTitle + +actionMovie_title :: AttrLabelProxy "title" +actionMovie_title = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@operation@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' actionMovie #operation +@ +-} +getActionMovieOperation :: MonadIO m => ActionMovie -> m Poppler.Enums.ActionMovieOperation +getActionMovieOperation s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 16) :: IO CUInt + let val' = (toEnum . fromIntegral) val + return val' + +{- | +Set the value of the “@operation@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' actionMovie [ #operation 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setActionMovieOperation :: MonadIO m => ActionMovie -> Poppler.Enums.ActionMovieOperation -> m () +setActionMovieOperation s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = (fromIntegral . fromEnum) val + poke (ptr `plusPtr` 16) (val' :: CUInt) + +#if ENABLE_OVERLOADING +data ActionMovieOperationFieldInfo +instance AttrInfo ActionMovieOperationFieldInfo where + type AttrAllowedOps ActionMovieOperationFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint ActionMovieOperationFieldInfo = (~) Poppler.Enums.ActionMovieOperation + type AttrBaseTypeConstraint ActionMovieOperationFieldInfo = (~) ActionMovie + type AttrGetType ActionMovieOperationFieldInfo = Poppler.Enums.ActionMovieOperation + type AttrLabel ActionMovieOperationFieldInfo = "operation" + type AttrOrigin ActionMovieOperationFieldInfo = ActionMovie + attrGet _ = getActionMovieOperation + attrSet _ = setActionMovieOperation + attrConstruct = undefined + attrClear _ = undefined + +actionMovie_operation :: AttrLabelProxy "operation" +actionMovie_operation = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@movie@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' actionMovie #movie +@ +-} +getActionMovieMovie :: MonadIO m => ActionMovie -> m (Maybe Poppler.Movie.Movie) +getActionMovieMovie s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 24) :: IO (Ptr Poppler.Movie.Movie) + result <- SP.convertIfNonNull val $ \val' -> do + val'' <- (newObject Poppler.Movie.Movie) val' + return val'' + return result + +{- | +Set the value of the “@movie@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' actionMovie [ #movie 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setActionMovieMovie :: MonadIO m => ActionMovie -> Ptr Poppler.Movie.Movie -> m () +setActionMovieMovie s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 24) (val :: Ptr Poppler.Movie.Movie) + +{- | +Set the value of the “@movie@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #movie +@ +-} +clearActionMovieMovie :: MonadIO m => ActionMovie -> m () +clearActionMovieMovie s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 24) (FP.nullPtr :: Ptr Poppler.Movie.Movie) + +#if ENABLE_OVERLOADING +data ActionMovieMovieFieldInfo +instance AttrInfo ActionMovieMovieFieldInfo where + type AttrAllowedOps ActionMovieMovieFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint ActionMovieMovieFieldInfo = (~) (Ptr Poppler.Movie.Movie) + type AttrBaseTypeConstraint ActionMovieMovieFieldInfo = (~) ActionMovie + type AttrGetType ActionMovieMovieFieldInfo = Maybe Poppler.Movie.Movie + type AttrLabel ActionMovieMovieFieldInfo = "movie" + type AttrOrigin ActionMovieMovieFieldInfo = ActionMovie + attrGet _ = getActionMovieMovie + attrSet _ = setActionMovieMovie + attrConstruct = undefined + attrClear _ = clearActionMovieMovie + +actionMovie_movie :: AttrLabelProxy "movie" +actionMovie_movie = AttrLabelProxy + +#endif + + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList ActionMovie +type instance O.AttributeList ActionMovie = ActionMovieAttributeList +type ActionMovieAttributeList = ('[ '("type", ActionMovieTypeFieldInfo), '("title", ActionMovieTitleFieldInfo), '("operation", ActionMovieOperationFieldInfo), '("movie", ActionMovieMovieFieldInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +type family ResolveActionMovieMethod (t :: Symbol) (o :: *) :: * where + ResolveActionMovieMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveActionMovieMethod t ActionMovie, O.MethodInfo info ActionMovie p) => OL.IsLabel t (ActionMovie -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + 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,26 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Poppler.Structs.ActionMovie where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype ActionMovie = ActionMovie (ManagedPtr ActionMovie) +instance WrappedPtr ActionMovie where 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,291 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Poppler.Structs.ActionNamed + ( + +-- * Exported types + ActionNamed(..) , + newZeroActionNamed , + noActionNamed , + + + -- * Properties +-- ** namedDest #attr:namedDest# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + actionNamed_namedDest , +#endif + clearActionNamedNamedDest , + getActionNamedNamedDest , + setActionNamedNamedDest , + + +-- ** title #attr:title# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + actionNamed_title , +#endif + clearActionNamedTitle , + getActionNamedTitle , + setActionNamedTitle , + + +-- ** type #attr:type# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + actionNamed_type , +#endif + getActionNamedType , + setActionNamedType , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import {-# SOURCE #-} qualified GI.Poppler.Enums as Poppler.Enums + +-- | Memory-managed wrapper type. +newtype ActionNamed = ActionNamed (ManagedPtr ActionNamed) +instance WrappedPtr ActionNamed where + wrappedPtrCalloc = callocBytes 24 + wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 24 >=> wrapPtr ActionNamed) + wrappedPtrFree = Just ptr_to_g_free + +-- | Construct a `ActionNamed` struct initialized to zero. +newZeroActionNamed :: MonadIO m => m ActionNamed +newZeroActionNamed = liftIO $ wrappedPtrCalloc >>= wrapPtr ActionNamed + +instance tag ~ 'AttrSet => Constructible ActionNamed tag where + new _ attrs = do + o <- newZeroActionNamed + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `ActionNamed`. +noActionNamed :: Maybe ActionNamed +noActionNamed = Nothing + +{- | +Get the value of the “@type@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' actionNamed #type +@ +-} +getActionNamedType :: MonadIO m => ActionNamed -> m Poppler.Enums.ActionType +getActionNamedType s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO CUInt + let val' = (toEnum . fromIntegral) val + return val' + +{- | +Set the value of the “@type@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' actionNamed [ #type 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setActionNamedType :: MonadIO m => ActionNamed -> Poppler.Enums.ActionType -> m () +setActionNamedType s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = (fromIntegral . fromEnum) val + poke (ptr `plusPtr` 0) (val' :: CUInt) + +#if ENABLE_OVERLOADING +data ActionNamedTypeFieldInfo +instance AttrInfo ActionNamedTypeFieldInfo where + type AttrAllowedOps ActionNamedTypeFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint ActionNamedTypeFieldInfo = (~) Poppler.Enums.ActionType + type AttrBaseTypeConstraint ActionNamedTypeFieldInfo = (~) ActionNamed + type AttrGetType ActionNamedTypeFieldInfo = Poppler.Enums.ActionType + type AttrLabel ActionNamedTypeFieldInfo = "type" + type AttrOrigin ActionNamedTypeFieldInfo = ActionNamed + attrGet _ = getActionNamedType + attrSet _ = setActionNamedType + attrConstruct = undefined + attrClear _ = undefined + +actionNamed_type :: AttrLabelProxy "type" +actionNamed_type = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@title@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' actionNamed #title +@ +-} +getActionNamedTitle :: MonadIO m => ActionNamed -> m (Maybe T.Text) +getActionNamedTitle s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 8) :: IO CString + result <- SP.convertIfNonNull val $ \val' -> do + val'' <- cstringToText val' + return val'' + return result + +{- | +Set the value of the “@title@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' actionNamed [ #title 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setActionNamedTitle :: MonadIO m => ActionNamed -> CString -> m () +setActionNamedTitle s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 8) (val :: CString) + +{- | +Set the value of the “@title@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #title +@ +-} +clearActionNamedTitle :: MonadIO m => ActionNamed -> m () +clearActionNamedTitle s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 8) (FP.nullPtr :: CString) + +#if ENABLE_OVERLOADING +data ActionNamedTitleFieldInfo +instance AttrInfo ActionNamedTitleFieldInfo where + type AttrAllowedOps ActionNamedTitleFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint ActionNamedTitleFieldInfo = (~) CString + type AttrBaseTypeConstraint ActionNamedTitleFieldInfo = (~) ActionNamed + type AttrGetType ActionNamedTitleFieldInfo = Maybe T.Text + type AttrLabel ActionNamedTitleFieldInfo = "title" + type AttrOrigin ActionNamedTitleFieldInfo = ActionNamed + attrGet _ = getActionNamedTitle + attrSet _ = setActionNamedTitle + attrConstruct = undefined + attrClear _ = clearActionNamedTitle + +actionNamed_title :: AttrLabelProxy "title" +actionNamed_title = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@named_dest@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' actionNamed #namedDest +@ +-} +getActionNamedNamedDest :: MonadIO m => ActionNamed -> m (Maybe T.Text) +getActionNamedNamedDest s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 16) :: IO CString + result <- SP.convertIfNonNull val $ \val' -> do + val'' <- cstringToText val' + return val'' + return result + +{- | +Set the value of the “@named_dest@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' actionNamed [ #namedDest 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setActionNamedNamedDest :: MonadIO m => ActionNamed -> CString -> m () +setActionNamedNamedDest s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 16) (val :: CString) + +{- | +Set the value of the “@named_dest@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #namedDest +@ +-} +clearActionNamedNamedDest :: MonadIO m => ActionNamed -> m () +clearActionNamedNamedDest s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 16) (FP.nullPtr :: CString) + +#if ENABLE_OVERLOADING +data ActionNamedNamedDestFieldInfo +instance AttrInfo ActionNamedNamedDestFieldInfo where + type AttrAllowedOps ActionNamedNamedDestFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint ActionNamedNamedDestFieldInfo = (~) CString + type AttrBaseTypeConstraint ActionNamedNamedDestFieldInfo = (~) ActionNamed + type AttrGetType ActionNamedNamedDestFieldInfo = Maybe T.Text + type AttrLabel ActionNamedNamedDestFieldInfo = "named_dest" + type AttrOrigin ActionNamedNamedDestFieldInfo = ActionNamed + attrGet _ = getActionNamedNamedDest + attrSet _ = setActionNamedNamedDest + attrConstruct = undefined + attrClear _ = clearActionNamedNamedDest + +actionNamed_namedDest :: AttrLabelProxy "namedDest" +actionNamed_namedDest = AttrLabelProxy + +#endif + + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList ActionNamed +type instance O.AttributeList ActionNamed = ActionNamedAttributeList +type ActionNamedAttributeList = ('[ '("type", ActionNamedTypeFieldInfo), '("title", ActionNamedTitleFieldInfo), '("namedDest", ActionNamedNamedDestFieldInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +type family ResolveActionNamedMethod (t :: Symbol) (o :: *) :: * where + ResolveActionNamedMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveActionNamedMethod t ActionNamed, O.MethodInfo info ActionNamed p) => OL.IsLabel t (ActionNamed -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + 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,26 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Poppler.Structs.ActionNamed where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype ActionNamed = ActionNamed (ManagedPtr ActionNamed) +instance WrappedPtr ActionNamed where 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,289 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Poppler.Structs.ActionOCGState + ( + +-- * Exported types + ActionOCGState(..) , + newZeroActionOCGState , + noActionOCGState , + + + -- * Properties +-- ** stateList #attr:stateList# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + actionOCGState_stateList , +#endif + clearActionOCGStateStateList , + getActionOCGStateStateList , + setActionOCGStateStateList , + + +-- ** title #attr:title# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + actionOCGState_title , +#endif + clearActionOCGStateTitle , + getActionOCGStateTitle , + setActionOCGStateTitle , + + +-- ** type #attr:type# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + actionOCGState_type , +#endif + getActionOCGStateType , + setActionOCGStateType , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import {-# SOURCE #-} qualified GI.Poppler.Enums as Poppler.Enums + +-- | Memory-managed wrapper type. +newtype ActionOCGState = ActionOCGState (ManagedPtr ActionOCGState) +instance WrappedPtr ActionOCGState where + wrappedPtrCalloc = callocBytes 24 + wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 24 >=> wrapPtr ActionOCGState) + wrappedPtrFree = Just ptr_to_g_free + +-- | Construct a `ActionOCGState` struct initialized to zero. +newZeroActionOCGState :: MonadIO m => m ActionOCGState +newZeroActionOCGState = liftIO $ wrappedPtrCalloc >>= wrapPtr ActionOCGState + +instance tag ~ 'AttrSet => Constructible ActionOCGState tag where + new _ attrs = do + o <- newZeroActionOCGState + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `ActionOCGState`. +noActionOCGState :: Maybe ActionOCGState +noActionOCGState = Nothing + +{- | +Get the value of the “@type@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' actionOCGState #type +@ +-} +getActionOCGStateType :: MonadIO m => ActionOCGState -> m Poppler.Enums.ActionType +getActionOCGStateType s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO CUInt + let val' = (toEnum . fromIntegral) val + return val' + +{- | +Set the value of the “@type@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' actionOCGState [ #type 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setActionOCGStateType :: MonadIO m => ActionOCGState -> Poppler.Enums.ActionType -> m () +setActionOCGStateType s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = (fromIntegral . fromEnum) val + poke (ptr `plusPtr` 0) (val' :: CUInt) + +#if ENABLE_OVERLOADING +data ActionOCGStateTypeFieldInfo +instance AttrInfo ActionOCGStateTypeFieldInfo where + type AttrAllowedOps ActionOCGStateTypeFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint ActionOCGStateTypeFieldInfo = (~) Poppler.Enums.ActionType + type AttrBaseTypeConstraint ActionOCGStateTypeFieldInfo = (~) ActionOCGState + type AttrGetType ActionOCGStateTypeFieldInfo = Poppler.Enums.ActionType + type AttrLabel ActionOCGStateTypeFieldInfo = "type" + type AttrOrigin ActionOCGStateTypeFieldInfo = ActionOCGState + attrGet _ = getActionOCGStateType + attrSet _ = setActionOCGStateType + attrConstruct = undefined + attrClear _ = undefined + +actionOCGState_type :: AttrLabelProxy "type" +actionOCGState_type = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@title@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' actionOCGState #title +@ +-} +getActionOCGStateTitle :: MonadIO m => ActionOCGState -> m (Maybe T.Text) +getActionOCGStateTitle s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 8) :: IO CString + result <- SP.convertIfNonNull val $ \val' -> do + val'' <- cstringToText val' + return val'' + return result + +{- | +Set the value of the “@title@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' actionOCGState [ #title 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setActionOCGStateTitle :: MonadIO m => ActionOCGState -> CString -> m () +setActionOCGStateTitle s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 8) (val :: CString) + +{- | +Set the value of the “@title@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #title +@ +-} +clearActionOCGStateTitle :: MonadIO m => ActionOCGState -> m () +clearActionOCGStateTitle s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 8) (FP.nullPtr :: CString) + +#if ENABLE_OVERLOADING +data ActionOCGStateTitleFieldInfo +instance AttrInfo ActionOCGStateTitleFieldInfo where + type AttrAllowedOps ActionOCGStateTitleFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint ActionOCGStateTitleFieldInfo = (~) CString + type AttrBaseTypeConstraint ActionOCGStateTitleFieldInfo = (~) ActionOCGState + type AttrGetType ActionOCGStateTitleFieldInfo = Maybe T.Text + type AttrLabel ActionOCGStateTitleFieldInfo = "title" + type AttrOrigin ActionOCGStateTitleFieldInfo = ActionOCGState + attrGet _ = getActionOCGStateTitle + attrSet _ = setActionOCGStateTitle + attrConstruct = undefined + attrClear _ = clearActionOCGStateTitle + +actionOCGState_title :: AttrLabelProxy "title" +actionOCGState_title = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@state_list@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' actionOCGState #stateList +@ +-} +getActionOCGStateStateList :: MonadIO m => ActionOCGState -> m ([Ptr ()]) +getActionOCGStateStateList s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 16) :: IO (Ptr (GList (Ptr ()))) + val' <- unpackGList val + return val' + +{- | +Set the value of the “@state_list@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' actionOCGState [ #stateList 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setActionOCGStateStateList :: MonadIO m => ActionOCGState -> Ptr (GList (Ptr ())) -> m () +setActionOCGStateStateList s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 16) (val :: Ptr (GList (Ptr ()))) + +{- | +Set the value of the “@state_list@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #stateList +@ +-} +clearActionOCGStateStateList :: MonadIO m => ActionOCGState -> m () +clearActionOCGStateStateList s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 16) (FP.nullPtr :: Ptr (GList (Ptr ()))) + +#if ENABLE_OVERLOADING +data ActionOCGStateStateListFieldInfo +instance AttrInfo ActionOCGStateStateListFieldInfo where + type AttrAllowedOps ActionOCGStateStateListFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint ActionOCGStateStateListFieldInfo = (~) (Ptr (GList (Ptr ()))) + type AttrBaseTypeConstraint ActionOCGStateStateListFieldInfo = (~) ActionOCGState + type AttrGetType ActionOCGStateStateListFieldInfo = [Ptr ()] + type AttrLabel ActionOCGStateStateListFieldInfo = "state_list" + type AttrOrigin ActionOCGStateStateListFieldInfo = ActionOCGState + attrGet _ = getActionOCGStateStateList + attrSet _ = setActionOCGStateStateList + attrConstruct = undefined + attrClear _ = clearActionOCGStateStateList + +actionOCGState_stateList :: AttrLabelProxy "stateList" +actionOCGState_stateList = AttrLabelProxy + +#endif + + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList ActionOCGState +type instance O.AttributeList ActionOCGState = ActionOCGStateAttributeList +type ActionOCGStateAttributeList = ('[ '("type", ActionOCGStateTypeFieldInfo), '("title", ActionOCGStateTitleFieldInfo), '("stateList", ActionOCGStateStateListFieldInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +type family ResolveActionOCGStateMethod (t :: Symbol) (o :: *) :: * where + ResolveActionOCGStateMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveActionOCGStateMethod t ActionOCGState, O.MethodInfo info ActionOCGState p) => OL.IsLabel t (ActionOCGState -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + 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,26 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Poppler.Structs.ActionOCGState where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype ActionOCGState = ActionOCGState (ManagedPtr ActionOCGState) +instance WrappedPtr ActionOCGState where 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,347 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Poppler.Structs.ActionRendition + ( + +-- * Exported types + ActionRendition(..) , + newZeroActionRendition , + noActionRendition , + + + -- * Properties +-- ** media #attr:media# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + actionRendition_media , +#endif + clearActionRenditionMedia , + getActionRenditionMedia , + setActionRenditionMedia , + + +-- ** op #attr:op# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + actionRendition_op , +#endif + getActionRenditionOp , + setActionRenditionOp , + + +-- ** title #attr:title# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + actionRendition_title , +#endif + clearActionRenditionTitle , + getActionRenditionTitle , + setActionRenditionTitle , + + +-- ** type #attr:type# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + actionRendition_type , +#endif + getActionRenditionType , + setActionRenditionType , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import {-# SOURCE #-} qualified GI.Poppler.Enums as Poppler.Enums +import {-# SOURCE #-} qualified GI.Poppler.Objects.Media as Poppler.Media + +-- | Memory-managed wrapper type. +newtype ActionRendition = ActionRendition (ManagedPtr ActionRendition) +instance WrappedPtr ActionRendition where + wrappedPtrCalloc = callocBytes 32 + wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 32 >=> wrapPtr ActionRendition) + wrappedPtrFree = Just ptr_to_g_free + +-- | Construct a `ActionRendition` struct initialized to zero. +newZeroActionRendition :: MonadIO m => m ActionRendition +newZeroActionRendition = liftIO $ wrappedPtrCalloc >>= wrapPtr ActionRendition + +instance tag ~ 'AttrSet => Constructible ActionRendition tag where + new _ attrs = do + o <- newZeroActionRendition + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `ActionRendition`. +noActionRendition :: Maybe ActionRendition +noActionRendition = Nothing + +{- | +Get the value of the “@type@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' actionRendition #type +@ +-} +getActionRenditionType :: MonadIO m => ActionRendition -> m Poppler.Enums.ActionType +getActionRenditionType s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO CUInt + let val' = (toEnum . fromIntegral) val + return val' + +{- | +Set the value of the “@type@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' actionRendition [ #type 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setActionRenditionType :: MonadIO m => ActionRendition -> Poppler.Enums.ActionType -> m () +setActionRenditionType s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = (fromIntegral . fromEnum) val + poke (ptr `plusPtr` 0) (val' :: CUInt) + +#if ENABLE_OVERLOADING +data ActionRenditionTypeFieldInfo +instance AttrInfo ActionRenditionTypeFieldInfo where + type AttrAllowedOps ActionRenditionTypeFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint ActionRenditionTypeFieldInfo = (~) Poppler.Enums.ActionType + type AttrBaseTypeConstraint ActionRenditionTypeFieldInfo = (~) ActionRendition + type AttrGetType ActionRenditionTypeFieldInfo = Poppler.Enums.ActionType + type AttrLabel ActionRenditionTypeFieldInfo = "type" + type AttrOrigin ActionRenditionTypeFieldInfo = ActionRendition + attrGet _ = getActionRenditionType + attrSet _ = setActionRenditionType + attrConstruct = undefined + attrClear _ = undefined + +actionRendition_type :: AttrLabelProxy "type" +actionRendition_type = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@title@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' actionRendition #title +@ +-} +getActionRenditionTitle :: MonadIO m => ActionRendition -> m (Maybe T.Text) +getActionRenditionTitle s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 8) :: IO CString + result <- SP.convertIfNonNull val $ \val' -> do + val'' <- cstringToText val' + return val'' + return result + +{- | +Set the value of the “@title@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' actionRendition [ #title 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setActionRenditionTitle :: MonadIO m => ActionRendition -> CString -> m () +setActionRenditionTitle s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 8) (val :: CString) + +{- | +Set the value of the “@title@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #title +@ +-} +clearActionRenditionTitle :: MonadIO m => ActionRendition -> m () +clearActionRenditionTitle s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 8) (FP.nullPtr :: CString) + +#if ENABLE_OVERLOADING +data ActionRenditionTitleFieldInfo +instance AttrInfo ActionRenditionTitleFieldInfo where + type AttrAllowedOps ActionRenditionTitleFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint ActionRenditionTitleFieldInfo = (~) CString + type AttrBaseTypeConstraint ActionRenditionTitleFieldInfo = (~) ActionRendition + type AttrGetType ActionRenditionTitleFieldInfo = Maybe T.Text + type AttrLabel ActionRenditionTitleFieldInfo = "title" + type AttrOrigin ActionRenditionTitleFieldInfo = ActionRendition + attrGet _ = getActionRenditionTitle + attrSet _ = setActionRenditionTitle + attrConstruct = undefined + attrClear _ = clearActionRenditionTitle + +actionRendition_title :: AttrLabelProxy "title" +actionRendition_title = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@op@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' actionRendition #op +@ +-} +getActionRenditionOp :: MonadIO m => ActionRendition -> m Int32 +getActionRenditionOp s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 16) :: IO Int32 + return val + +{- | +Set the value of the “@op@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' actionRendition [ #op 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setActionRenditionOp :: MonadIO m => ActionRendition -> Int32 -> m () +setActionRenditionOp s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 16) (val :: Int32) + +#if ENABLE_OVERLOADING +data ActionRenditionOpFieldInfo +instance AttrInfo ActionRenditionOpFieldInfo where + type AttrAllowedOps ActionRenditionOpFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint ActionRenditionOpFieldInfo = (~) Int32 + type AttrBaseTypeConstraint ActionRenditionOpFieldInfo = (~) ActionRendition + type AttrGetType ActionRenditionOpFieldInfo = Int32 + type AttrLabel ActionRenditionOpFieldInfo = "op" + type AttrOrigin ActionRenditionOpFieldInfo = ActionRendition + attrGet _ = getActionRenditionOp + attrSet _ = setActionRenditionOp + attrConstruct = undefined + attrClear _ = undefined + +actionRendition_op :: AttrLabelProxy "op" +actionRendition_op = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@media@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' actionRendition #media +@ +-} +getActionRenditionMedia :: MonadIO m => ActionRendition -> m (Maybe Poppler.Media.Media) +getActionRenditionMedia s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 24) :: IO (Ptr Poppler.Media.Media) + result <- SP.convertIfNonNull val $ \val' -> do + val'' <- (newObject Poppler.Media.Media) val' + return val'' + return result + +{- | +Set the value of the “@media@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' actionRendition [ #media 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setActionRenditionMedia :: MonadIO m => ActionRendition -> Ptr Poppler.Media.Media -> m () +setActionRenditionMedia s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 24) (val :: Ptr Poppler.Media.Media) + +{- | +Set the value of the “@media@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #media +@ +-} +clearActionRenditionMedia :: MonadIO m => ActionRendition -> m () +clearActionRenditionMedia s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 24) (FP.nullPtr :: Ptr Poppler.Media.Media) + +#if ENABLE_OVERLOADING +data ActionRenditionMediaFieldInfo +instance AttrInfo ActionRenditionMediaFieldInfo where + type AttrAllowedOps ActionRenditionMediaFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint ActionRenditionMediaFieldInfo = (~) (Ptr Poppler.Media.Media) + type AttrBaseTypeConstraint ActionRenditionMediaFieldInfo = (~) ActionRendition + type AttrGetType ActionRenditionMediaFieldInfo = Maybe Poppler.Media.Media + type AttrLabel ActionRenditionMediaFieldInfo = "media" + type AttrOrigin ActionRenditionMediaFieldInfo = ActionRendition + attrGet _ = getActionRenditionMedia + attrSet _ = setActionRenditionMedia + attrConstruct = undefined + attrClear _ = clearActionRenditionMedia + +actionRendition_media :: AttrLabelProxy "media" +actionRendition_media = AttrLabelProxy + +#endif + + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList ActionRendition +type instance O.AttributeList ActionRendition = ActionRenditionAttributeList +type ActionRenditionAttributeList = ('[ '("type", ActionRenditionTypeFieldInfo), '("title", ActionRenditionTitleFieldInfo), '("op", ActionRenditionOpFieldInfo), '("media", ActionRenditionMediaFieldInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +type family ResolveActionRenditionMethod (t :: Symbol) (o :: *) :: * where + ResolveActionRenditionMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveActionRenditionMethod t ActionRendition, O.MethodInfo info ActionRendition p) => OL.IsLabel t (ActionRendition -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + 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,26 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Poppler.Structs.ActionRendition where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype ActionRendition = ActionRendition (ManagedPtr ActionRendition) +instance WrappedPtr ActionRendition where 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,291 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Poppler.Structs.ActionUri + ( + +-- * Exported types + ActionUri(..) , + newZeroActionUri , + noActionUri , + + + -- * Properties +-- ** title #attr:title# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + actionUri_title , +#endif + clearActionUriTitle , + getActionUriTitle , + setActionUriTitle , + + +-- ** type #attr:type# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + actionUri_type , +#endif + getActionUriType , + setActionUriType , + + +-- ** uri #attr:uri# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + actionUri_uri , +#endif + clearActionUriUri , + getActionUriUri , + setActionUriUri , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import {-# SOURCE #-} qualified GI.Poppler.Enums as Poppler.Enums + +-- | Memory-managed wrapper type. +newtype ActionUri = ActionUri (ManagedPtr ActionUri) +instance WrappedPtr ActionUri where + wrappedPtrCalloc = callocBytes 24 + wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 24 >=> wrapPtr ActionUri) + wrappedPtrFree = Just ptr_to_g_free + +-- | Construct a `ActionUri` struct initialized to zero. +newZeroActionUri :: MonadIO m => m ActionUri +newZeroActionUri = liftIO $ wrappedPtrCalloc >>= wrapPtr ActionUri + +instance tag ~ 'AttrSet => Constructible ActionUri tag where + new _ attrs = do + o <- newZeroActionUri + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `ActionUri`. +noActionUri :: Maybe ActionUri +noActionUri = Nothing + +{- | +Get the value of the “@type@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' actionUri #type +@ +-} +getActionUriType :: MonadIO m => ActionUri -> m Poppler.Enums.ActionType +getActionUriType s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO CUInt + let val' = (toEnum . fromIntegral) val + return val' + +{- | +Set the value of the “@type@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' actionUri [ #type 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setActionUriType :: MonadIO m => ActionUri -> Poppler.Enums.ActionType -> m () +setActionUriType s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = (fromIntegral . fromEnum) val + poke (ptr `plusPtr` 0) (val' :: CUInt) + +#if ENABLE_OVERLOADING +data ActionUriTypeFieldInfo +instance AttrInfo ActionUriTypeFieldInfo where + type AttrAllowedOps ActionUriTypeFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint ActionUriTypeFieldInfo = (~) Poppler.Enums.ActionType + type AttrBaseTypeConstraint ActionUriTypeFieldInfo = (~) ActionUri + type AttrGetType ActionUriTypeFieldInfo = Poppler.Enums.ActionType + type AttrLabel ActionUriTypeFieldInfo = "type" + type AttrOrigin ActionUriTypeFieldInfo = ActionUri + attrGet _ = getActionUriType + attrSet _ = setActionUriType + attrConstruct = undefined + attrClear _ = undefined + +actionUri_type :: AttrLabelProxy "type" +actionUri_type = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@title@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' actionUri #title +@ +-} +getActionUriTitle :: MonadIO m => ActionUri -> m (Maybe T.Text) +getActionUriTitle s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 8) :: IO CString + result <- SP.convertIfNonNull val $ \val' -> do + val'' <- cstringToText val' + return val'' + return result + +{- | +Set the value of the “@title@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' actionUri [ #title 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setActionUriTitle :: MonadIO m => ActionUri -> CString -> m () +setActionUriTitle s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 8) (val :: CString) + +{- | +Set the value of the “@title@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #title +@ +-} +clearActionUriTitle :: MonadIO m => ActionUri -> m () +clearActionUriTitle s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 8) (FP.nullPtr :: CString) + +#if ENABLE_OVERLOADING +data ActionUriTitleFieldInfo +instance AttrInfo ActionUriTitleFieldInfo where + type AttrAllowedOps ActionUriTitleFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint ActionUriTitleFieldInfo = (~) CString + type AttrBaseTypeConstraint ActionUriTitleFieldInfo = (~) ActionUri + type AttrGetType ActionUriTitleFieldInfo = Maybe T.Text + type AttrLabel ActionUriTitleFieldInfo = "title" + type AttrOrigin ActionUriTitleFieldInfo = ActionUri + attrGet _ = getActionUriTitle + attrSet _ = setActionUriTitle + attrConstruct = undefined + attrClear _ = clearActionUriTitle + +actionUri_title :: AttrLabelProxy "title" +actionUri_title = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@uri@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' actionUri #uri +@ +-} +getActionUriUri :: MonadIO m => ActionUri -> m (Maybe T.Text) +getActionUriUri s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 16) :: IO CString + result <- SP.convertIfNonNull val $ \val' -> do + val'' <- cstringToText val' + return val'' + return result + +{- | +Set the value of the “@uri@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' actionUri [ #uri 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setActionUriUri :: MonadIO m => ActionUri -> CString -> m () +setActionUriUri s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 16) (val :: CString) + +{- | +Set the value of the “@uri@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #uri +@ +-} +clearActionUriUri :: MonadIO m => ActionUri -> m () +clearActionUriUri s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 16) (FP.nullPtr :: CString) + +#if ENABLE_OVERLOADING +data ActionUriUriFieldInfo +instance AttrInfo ActionUriUriFieldInfo where + type AttrAllowedOps ActionUriUriFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint ActionUriUriFieldInfo = (~) CString + type AttrBaseTypeConstraint ActionUriUriFieldInfo = (~) ActionUri + type AttrGetType ActionUriUriFieldInfo = Maybe T.Text + type AttrLabel ActionUriUriFieldInfo = "uri" + type AttrOrigin ActionUriUriFieldInfo = ActionUri + attrGet _ = getActionUriUri + attrSet _ = setActionUriUri + attrConstruct = undefined + attrClear _ = clearActionUriUri + +actionUri_uri :: AttrLabelProxy "uri" +actionUri_uri = AttrLabelProxy + +#endif + + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList ActionUri +type instance O.AttributeList ActionUri = ActionUriAttributeList +type ActionUriAttributeList = ('[ '("type", ActionUriTypeFieldInfo), '("title", ActionUriTitleFieldInfo), '("uri", ActionUriUriFieldInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +type family ResolveActionUriMethod (t :: Symbol) (o :: *) :: * where + ResolveActionUriMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveActionUriMethod t ActionUri, O.MethodInfo info ActionUri p) => OL.IsLabel t (ActionUri -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + 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,26 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Poppler.Structs.ActionUri where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype ActionUri = ActionUri (ManagedPtr ActionUri) +instance WrappedPtr ActionUri where 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,615 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Poppler.Structs.AnnotCalloutLine + ( + +-- * Exported types + AnnotCalloutLine(..) , + newZeroAnnotCalloutLine , + noAnnotCalloutLine , + + + -- * Methods +-- ** copy #method:copy# + +#if ENABLE_OVERLOADING + AnnotCalloutLineCopyMethodInfo , +#endif + annotCalloutLineCopy , + + +-- ** free #method:free# + +#if ENABLE_OVERLOADING + AnnotCalloutLineFreeMethodInfo , +#endif + annotCalloutLineFree , + + +-- ** new #method:new# + + annotCalloutLineNew , + + + + + -- * Properties +-- ** multiline #attr:multiline# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + annotCalloutLine_multiline , +#endif + getAnnotCalloutLineMultiline , + setAnnotCalloutLineMultiline , + + +-- ** x1 #attr:x1# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + annotCalloutLine_x1 , +#endif + getAnnotCalloutLineX1 , + setAnnotCalloutLineX1 , + + +-- ** x2 #attr:x2# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + annotCalloutLine_x2 , +#endif + getAnnotCalloutLineX2 , + setAnnotCalloutLineX2 , + + +-- ** x3 #attr:x3# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + annotCalloutLine_x3 , +#endif + getAnnotCalloutLineX3 , + setAnnotCalloutLineX3 , + + +-- ** y1 #attr:y1# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + annotCalloutLine_y1 , +#endif + getAnnotCalloutLineY1 , + setAnnotCalloutLineY1 , + + +-- ** y2 #attr:y2# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + annotCalloutLine_y2 , +#endif + getAnnotCalloutLineY2 , + setAnnotCalloutLineY2 , + + +-- ** y3 #attr:y3# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + annotCalloutLine_y3 , +#endif + getAnnotCalloutLineY3 , + setAnnotCalloutLineY3 , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + + +-- | Memory-managed wrapper type. +newtype AnnotCalloutLine = AnnotCalloutLine (ManagedPtr AnnotCalloutLine) +foreign import ccall "poppler_annot_callout_line_get_type" c_poppler_annot_callout_line_get_type :: + IO GType + +instance BoxedObject AnnotCalloutLine where + boxedType _ = c_poppler_annot_callout_line_get_type + +-- | Construct a `AnnotCalloutLine` struct initialized to zero. +newZeroAnnotCalloutLine :: MonadIO m => m AnnotCalloutLine +newZeroAnnotCalloutLine = liftIO $ callocBoxedBytes 56 >>= wrapBoxed AnnotCalloutLine + +instance tag ~ 'AttrSet => Constructible AnnotCalloutLine tag where + new _ attrs = do + o <- newZeroAnnotCalloutLine + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `AnnotCalloutLine`. +noAnnotCalloutLine :: Maybe AnnotCalloutLine +noAnnotCalloutLine = Nothing + +{- | +Get the value of the “@multiline@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' annotCalloutLine #multiline +@ +-} +getAnnotCalloutLineMultiline :: MonadIO m => AnnotCalloutLine -> m Bool +getAnnotCalloutLineMultiline s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO CInt + let val' = (/= 0) val + return val' + +{- | +Set the value of the “@multiline@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' annotCalloutLine [ #multiline 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setAnnotCalloutLineMultiline :: MonadIO m => AnnotCalloutLine -> Bool -> m () +setAnnotCalloutLineMultiline s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = (fromIntegral . fromEnum) val + poke (ptr `plusPtr` 0) (val' :: CInt) + +#if ENABLE_OVERLOADING +data AnnotCalloutLineMultilineFieldInfo +instance AttrInfo AnnotCalloutLineMultilineFieldInfo where + type AttrAllowedOps AnnotCalloutLineMultilineFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint AnnotCalloutLineMultilineFieldInfo = (~) Bool + type AttrBaseTypeConstraint AnnotCalloutLineMultilineFieldInfo = (~) AnnotCalloutLine + type AttrGetType AnnotCalloutLineMultilineFieldInfo = Bool + type AttrLabel AnnotCalloutLineMultilineFieldInfo = "multiline" + type AttrOrigin AnnotCalloutLineMultilineFieldInfo = AnnotCalloutLine + attrGet _ = getAnnotCalloutLineMultiline + attrSet _ = setAnnotCalloutLineMultiline + attrConstruct = undefined + attrClear _ = undefined + +annotCalloutLine_multiline :: AttrLabelProxy "multiline" +annotCalloutLine_multiline = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@x1@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' annotCalloutLine #x1 +@ +-} +getAnnotCalloutLineX1 :: MonadIO m => AnnotCalloutLine -> m Double +getAnnotCalloutLineX1 s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 8) :: IO CDouble + let val' = realToFrac val + return val' + +{- | +Set the value of the “@x1@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' annotCalloutLine [ #x1 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setAnnotCalloutLineX1 :: MonadIO m => AnnotCalloutLine -> Double -> m () +setAnnotCalloutLineX1 s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = realToFrac val + poke (ptr `plusPtr` 8) (val' :: CDouble) + +#if ENABLE_OVERLOADING +data AnnotCalloutLineX1FieldInfo +instance AttrInfo AnnotCalloutLineX1FieldInfo where + type AttrAllowedOps AnnotCalloutLineX1FieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint AnnotCalloutLineX1FieldInfo = (~) Double + type AttrBaseTypeConstraint AnnotCalloutLineX1FieldInfo = (~) AnnotCalloutLine + type AttrGetType AnnotCalloutLineX1FieldInfo = Double + type AttrLabel AnnotCalloutLineX1FieldInfo = "x1" + type AttrOrigin AnnotCalloutLineX1FieldInfo = AnnotCalloutLine + attrGet _ = getAnnotCalloutLineX1 + attrSet _ = setAnnotCalloutLineX1 + attrConstruct = undefined + attrClear _ = undefined + +annotCalloutLine_x1 :: AttrLabelProxy "x1" +annotCalloutLine_x1 = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@y1@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' annotCalloutLine #y1 +@ +-} +getAnnotCalloutLineY1 :: MonadIO m => AnnotCalloutLine -> m Double +getAnnotCalloutLineY1 s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 16) :: IO CDouble + let val' = realToFrac val + return val' + +{- | +Set the value of the “@y1@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' annotCalloutLine [ #y1 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setAnnotCalloutLineY1 :: MonadIO m => AnnotCalloutLine -> Double -> m () +setAnnotCalloutLineY1 s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = realToFrac val + poke (ptr `plusPtr` 16) (val' :: CDouble) + +#if ENABLE_OVERLOADING +data AnnotCalloutLineY1FieldInfo +instance AttrInfo AnnotCalloutLineY1FieldInfo where + type AttrAllowedOps AnnotCalloutLineY1FieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint AnnotCalloutLineY1FieldInfo = (~) Double + type AttrBaseTypeConstraint AnnotCalloutLineY1FieldInfo = (~) AnnotCalloutLine + type AttrGetType AnnotCalloutLineY1FieldInfo = Double + type AttrLabel AnnotCalloutLineY1FieldInfo = "y1" + type AttrOrigin AnnotCalloutLineY1FieldInfo = AnnotCalloutLine + attrGet _ = getAnnotCalloutLineY1 + attrSet _ = setAnnotCalloutLineY1 + attrConstruct = undefined + attrClear _ = undefined + +annotCalloutLine_y1 :: AttrLabelProxy "y1" +annotCalloutLine_y1 = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@x2@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' annotCalloutLine #x2 +@ +-} +getAnnotCalloutLineX2 :: MonadIO m => AnnotCalloutLine -> m Double +getAnnotCalloutLineX2 s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 24) :: IO CDouble + let val' = realToFrac val + return val' + +{- | +Set the value of the “@x2@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' annotCalloutLine [ #x2 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setAnnotCalloutLineX2 :: MonadIO m => AnnotCalloutLine -> Double -> m () +setAnnotCalloutLineX2 s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = realToFrac val + poke (ptr `plusPtr` 24) (val' :: CDouble) + +#if ENABLE_OVERLOADING +data AnnotCalloutLineX2FieldInfo +instance AttrInfo AnnotCalloutLineX2FieldInfo where + type AttrAllowedOps AnnotCalloutLineX2FieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint AnnotCalloutLineX2FieldInfo = (~) Double + type AttrBaseTypeConstraint AnnotCalloutLineX2FieldInfo = (~) AnnotCalloutLine + type AttrGetType AnnotCalloutLineX2FieldInfo = Double + type AttrLabel AnnotCalloutLineX2FieldInfo = "x2" + type AttrOrigin AnnotCalloutLineX2FieldInfo = AnnotCalloutLine + attrGet _ = getAnnotCalloutLineX2 + attrSet _ = setAnnotCalloutLineX2 + attrConstruct = undefined + attrClear _ = undefined + +annotCalloutLine_x2 :: AttrLabelProxy "x2" +annotCalloutLine_x2 = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@y2@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' annotCalloutLine #y2 +@ +-} +getAnnotCalloutLineY2 :: MonadIO m => AnnotCalloutLine -> m Double +getAnnotCalloutLineY2 s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 32) :: IO CDouble + let val' = realToFrac val + return val' + +{- | +Set the value of the “@y2@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' annotCalloutLine [ #y2 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setAnnotCalloutLineY2 :: MonadIO m => AnnotCalloutLine -> Double -> m () +setAnnotCalloutLineY2 s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = realToFrac val + poke (ptr `plusPtr` 32) (val' :: CDouble) + +#if ENABLE_OVERLOADING +data AnnotCalloutLineY2FieldInfo +instance AttrInfo AnnotCalloutLineY2FieldInfo where + type AttrAllowedOps AnnotCalloutLineY2FieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint AnnotCalloutLineY2FieldInfo = (~) Double + type AttrBaseTypeConstraint AnnotCalloutLineY2FieldInfo = (~) AnnotCalloutLine + type AttrGetType AnnotCalloutLineY2FieldInfo = Double + type AttrLabel AnnotCalloutLineY2FieldInfo = "y2" + type AttrOrigin AnnotCalloutLineY2FieldInfo = AnnotCalloutLine + attrGet _ = getAnnotCalloutLineY2 + attrSet _ = setAnnotCalloutLineY2 + attrConstruct = undefined + attrClear _ = undefined + +annotCalloutLine_y2 :: AttrLabelProxy "y2" +annotCalloutLine_y2 = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@x3@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' annotCalloutLine #x3 +@ +-} +getAnnotCalloutLineX3 :: MonadIO m => AnnotCalloutLine -> m Double +getAnnotCalloutLineX3 s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 40) :: IO CDouble + let val' = realToFrac val + return val' + +{- | +Set the value of the “@x3@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' annotCalloutLine [ #x3 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setAnnotCalloutLineX3 :: MonadIO m => AnnotCalloutLine -> Double -> m () +setAnnotCalloutLineX3 s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = realToFrac val + poke (ptr `plusPtr` 40) (val' :: CDouble) + +#if ENABLE_OVERLOADING +data AnnotCalloutLineX3FieldInfo +instance AttrInfo AnnotCalloutLineX3FieldInfo where + type AttrAllowedOps AnnotCalloutLineX3FieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint AnnotCalloutLineX3FieldInfo = (~) Double + type AttrBaseTypeConstraint AnnotCalloutLineX3FieldInfo = (~) AnnotCalloutLine + type AttrGetType AnnotCalloutLineX3FieldInfo = Double + type AttrLabel AnnotCalloutLineX3FieldInfo = "x3" + type AttrOrigin AnnotCalloutLineX3FieldInfo = AnnotCalloutLine + attrGet _ = getAnnotCalloutLineX3 + attrSet _ = setAnnotCalloutLineX3 + attrConstruct = undefined + attrClear _ = undefined + +annotCalloutLine_x3 :: AttrLabelProxy "x3" +annotCalloutLine_x3 = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@y3@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' annotCalloutLine #y3 +@ +-} +getAnnotCalloutLineY3 :: MonadIO m => AnnotCalloutLine -> m Double +getAnnotCalloutLineY3 s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 48) :: IO CDouble + let val' = realToFrac val + return val' + +{- | +Set the value of the “@y3@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' annotCalloutLine [ #y3 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setAnnotCalloutLineY3 :: MonadIO m => AnnotCalloutLine -> Double -> m () +setAnnotCalloutLineY3 s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = realToFrac val + poke (ptr `plusPtr` 48) (val' :: CDouble) + +#if ENABLE_OVERLOADING +data AnnotCalloutLineY3FieldInfo +instance AttrInfo AnnotCalloutLineY3FieldInfo where + type AttrAllowedOps AnnotCalloutLineY3FieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint AnnotCalloutLineY3FieldInfo = (~) Double + type AttrBaseTypeConstraint AnnotCalloutLineY3FieldInfo = (~) AnnotCalloutLine + type AttrGetType AnnotCalloutLineY3FieldInfo = Double + type AttrLabel AnnotCalloutLineY3FieldInfo = "y3" + type AttrOrigin AnnotCalloutLineY3FieldInfo = AnnotCalloutLine + attrGet _ = getAnnotCalloutLineY3 + attrSet _ = setAnnotCalloutLineY3 + attrConstruct = undefined + attrClear _ = undefined + +annotCalloutLine_y3 :: AttrLabelProxy "y3" +annotCalloutLine_y3 = AttrLabelProxy + +#endif + + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList AnnotCalloutLine +type instance O.AttributeList AnnotCalloutLine = AnnotCalloutLineAttributeList +type AnnotCalloutLineAttributeList = ('[ '("multiline", AnnotCalloutLineMultilineFieldInfo), '("x1", AnnotCalloutLineX1FieldInfo), '("y1", AnnotCalloutLineY1FieldInfo), '("x2", AnnotCalloutLineX2FieldInfo), '("y2", AnnotCalloutLineY2FieldInfo), '("x3", AnnotCalloutLineX3FieldInfo), '("y3", AnnotCalloutLineY3FieldInfo)] :: [(Symbol, *)]) +#endif + +-- method AnnotCalloutLine::new +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "AnnotCalloutLine"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_annot_callout_line_new" poppler_annot_callout_line_new :: + IO (Ptr AnnotCalloutLine) + +{- | +Creates a new empty 'GI.Poppler.Structs.AnnotCalloutLine.AnnotCalloutLine'. +-} +annotCalloutLineNew :: + (B.CallStack.HasCallStack, MonadIO m) => + m AnnotCalloutLine + {- ^ __Returns:__ a new allocated 'GI.Poppler.Structs.AnnotCalloutLine.AnnotCalloutLine', 'Nothing' in other case. + It must be freed when done. -} +annotCalloutLineNew = liftIO $ do + result <- poppler_annot_callout_line_new + checkUnexpectedReturnNULL "annotCalloutLineNew" result + result' <- (wrapBoxed AnnotCalloutLine) result + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method AnnotCalloutLine::copy +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "callout", argType = TInterface (Name {namespace = "Poppler", name = "AnnotCalloutLine"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #PopplerAnnotCalloutLine to be copied.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "AnnotCalloutLine"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_annot_callout_line_copy" poppler_annot_callout_line_copy :: + Ptr AnnotCalloutLine -> -- callout : TInterface (Name {namespace = "Poppler", name = "AnnotCalloutLine"}) + IO (Ptr AnnotCalloutLine) + +{- | +It does copy /@callout@/ to a new 'GI.Poppler.Structs.AnnotCalloutLine.AnnotCalloutLine'. +-} +annotCalloutLineCopy :: + (B.CallStack.HasCallStack, MonadIO m) => + AnnotCalloutLine + {- ^ /@callout@/: the 'GI.Poppler.Structs.AnnotCalloutLine.AnnotCalloutLine' to be copied. -} + -> m AnnotCalloutLine + {- ^ __Returns:__ a new allocated 'GI.Poppler.Structs.AnnotCalloutLine.AnnotCalloutLine' as exact copy of + /@callout@/, 'Nothing' in other case. It must be freed when done. -} +annotCalloutLineCopy callout = liftIO $ do + callout' <- unsafeManagedPtrGetPtr callout + result <- poppler_annot_callout_line_copy callout' + checkUnexpectedReturnNULL "annotCalloutLineCopy" result + result' <- (wrapBoxed AnnotCalloutLine) result + touchManagedPtr callout + return result' + +#if ENABLE_OVERLOADING +data AnnotCalloutLineCopyMethodInfo +instance (signature ~ (m AnnotCalloutLine), MonadIO m) => O.MethodInfo AnnotCalloutLineCopyMethodInfo AnnotCalloutLine signature where + overloadedMethod _ = annotCalloutLineCopy + +#endif + +-- method AnnotCalloutLine::free +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "callout", argType = TInterface (Name {namespace = "Poppler", name = "AnnotCalloutLine"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerAnnotCalloutLine", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_annot_callout_line_free" poppler_annot_callout_line_free :: + Ptr AnnotCalloutLine -> -- callout : TInterface (Name {namespace = "Poppler", name = "AnnotCalloutLine"}) + IO () + +{- | +Frees the memory used by 'GI.Poppler.Structs.AnnotCalloutLine.AnnotCalloutLine'. +-} +annotCalloutLineFree :: + (B.CallStack.HasCallStack, MonadIO m) => + AnnotCalloutLine + {- ^ /@callout@/: a 'GI.Poppler.Structs.AnnotCalloutLine.AnnotCalloutLine' -} + -> m () +annotCalloutLineFree callout = liftIO $ do + callout' <- unsafeManagedPtrGetPtr callout + poppler_annot_callout_line_free callout' + touchManagedPtr callout + return () + +#if ENABLE_OVERLOADING +data AnnotCalloutLineFreeMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo AnnotCalloutLineFreeMethodInfo AnnotCalloutLine signature where + overloadedMethod _ = annotCalloutLineFree + +#endif + +#if ENABLE_OVERLOADING +type family ResolveAnnotCalloutLineMethod (t :: Symbol) (o :: *) :: * where + ResolveAnnotCalloutLineMethod "copy" o = AnnotCalloutLineCopyMethodInfo + ResolveAnnotCalloutLineMethod "free" o = AnnotCalloutLineFreeMethodInfo + ResolveAnnotCalloutLineMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveAnnotCalloutLineMethod t AnnotCalloutLine, O.MethodInfo info AnnotCalloutLine p) => OL.IsLabel t (AnnotCalloutLine -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + 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,32 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Poppler.Structs.AnnotCalloutLine where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype AnnotCalloutLine = AnnotCalloutLine (ManagedPtr AnnotCalloutLine) +instance BoxedObject AnnotCalloutLine where +#if ENABLE_OVERLOADING +data AnnotCalloutLineCopyMethodInfo +#endif +#if ENABLE_OVERLOADING +data AnnotCalloutLineFreeMethodInfo +#endif 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,331 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +A 'GI.Poppler.Structs.AnnotMapping.AnnotMapping' structure represents the location +of /@annot@/ on the page +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Poppler.Structs.AnnotMapping + ( + +-- * Exported types + AnnotMapping(..) , + newZeroAnnotMapping , + noAnnotMapping , + + + -- * Methods +-- ** copy #method:copy# + +#if ENABLE_OVERLOADING + AnnotMappingCopyMethodInfo , +#endif + annotMappingCopy , + + +-- ** free #method:free# + +#if ENABLE_OVERLOADING + AnnotMappingFreeMethodInfo , +#endif + annotMappingFree , + + +-- ** new #method:new# + + annotMappingNew , + + + + + -- * Properties +-- ** annot #attr:annot# +{- | a 'GI.Poppler.Objects.Annot.Annot' +-} +#if ENABLE_OVERLOADING + annotMapping_annot , +#endif + clearAnnotMappingAnnot , + getAnnotMappingAnnot , + setAnnotMappingAnnot , + + +-- ** area #attr:area# +{- | a 'GI.Poppler.Structs.Rectangle.Rectangle' representing an area of the page +-} +#if ENABLE_OVERLOADING + annotMapping_area , +#endif + getAnnotMappingArea , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import {-# SOURCE #-} qualified GI.Poppler.Objects.Annot as Poppler.Annot +import {-# SOURCE #-} qualified GI.Poppler.Structs.Rectangle as Poppler.Rectangle + +-- | Memory-managed wrapper type. +newtype AnnotMapping = AnnotMapping (ManagedPtr 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 + +-- | Construct a `AnnotMapping` struct initialized to zero. +newZeroAnnotMapping :: MonadIO m => m AnnotMapping +newZeroAnnotMapping = liftIO $ callocBoxedBytes 40 >>= wrapBoxed AnnotMapping + +instance tag ~ 'AttrSet => Constructible AnnotMapping tag where + new _ attrs = do + o <- newZeroAnnotMapping + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `AnnotMapping`. +noAnnotMapping :: Maybe AnnotMapping +noAnnotMapping = Nothing + +{- | +Get the value of the “@area@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' annotMapping #area +@ +-} +getAnnotMappingArea :: MonadIO m => AnnotMapping -> m Poppler.Rectangle.Rectangle +getAnnotMappingArea s = liftIO $ withManagedPtr s $ \ptr -> do + let val = ptr `plusPtr` 0 :: (Ptr Poppler.Rectangle.Rectangle) + val' <- (newBoxed Poppler.Rectangle.Rectangle) val + return val' + +#if ENABLE_OVERLOADING +data AnnotMappingAreaFieldInfo +instance AttrInfo AnnotMappingAreaFieldInfo where + type AttrAllowedOps AnnotMappingAreaFieldInfo = '[ 'AttrGet] + type AttrSetTypeConstraint AnnotMappingAreaFieldInfo = (~) (Ptr Poppler.Rectangle.Rectangle) + type AttrBaseTypeConstraint AnnotMappingAreaFieldInfo = (~) AnnotMapping + type AttrGetType AnnotMappingAreaFieldInfo = Poppler.Rectangle.Rectangle + type AttrLabel AnnotMappingAreaFieldInfo = "area" + type AttrOrigin AnnotMappingAreaFieldInfo = AnnotMapping + attrGet _ = getAnnotMappingArea + attrSet _ = undefined + attrConstruct = undefined + attrClear _ = undefined + +annotMapping_area :: AttrLabelProxy "area" +annotMapping_area = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@annot@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' annotMapping #annot +@ +-} +getAnnotMappingAnnot :: MonadIO m => AnnotMapping -> m (Maybe Poppler.Annot.Annot) +getAnnotMappingAnnot s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 32) :: IO (Ptr Poppler.Annot.Annot) + result <- SP.convertIfNonNull val $ \val' -> do + val'' <- (newObject Poppler.Annot.Annot) val' + return val'' + return result + +{- | +Set the value of the “@annot@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' annotMapping [ #annot 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setAnnotMappingAnnot :: MonadIO m => AnnotMapping -> Ptr Poppler.Annot.Annot -> m () +setAnnotMappingAnnot s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 32) (val :: Ptr Poppler.Annot.Annot) + +{- | +Set the value of the “@annot@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #annot +@ +-} +clearAnnotMappingAnnot :: MonadIO m => AnnotMapping -> m () +clearAnnotMappingAnnot s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 32) (FP.nullPtr :: Ptr Poppler.Annot.Annot) + +#if ENABLE_OVERLOADING +data AnnotMappingAnnotFieldInfo +instance AttrInfo AnnotMappingAnnotFieldInfo where + type AttrAllowedOps AnnotMappingAnnotFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint AnnotMappingAnnotFieldInfo = (~) (Ptr Poppler.Annot.Annot) + type AttrBaseTypeConstraint AnnotMappingAnnotFieldInfo = (~) AnnotMapping + type AttrGetType AnnotMappingAnnotFieldInfo = Maybe Poppler.Annot.Annot + type AttrLabel AnnotMappingAnnotFieldInfo = "annot" + type AttrOrigin AnnotMappingAnnotFieldInfo = AnnotMapping + attrGet _ = getAnnotMappingAnnot + attrSet _ = setAnnotMappingAnnot + attrConstruct = undefined + attrClear _ = clearAnnotMappingAnnot + +annotMapping_annot :: AttrLabelProxy "annot" +annotMapping_annot = AttrLabelProxy + +#endif + + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList AnnotMapping +type instance O.AttributeList AnnotMapping = AnnotMappingAttributeList +type AnnotMappingAttributeList = ('[ '("area", AnnotMappingAreaFieldInfo), '("annot", AnnotMappingAnnotFieldInfo)] :: [(Symbol, *)]) +#endif + +-- method AnnotMapping::new +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "AnnotMapping"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_annot_mapping_new" poppler_annot_mapping_new :: + IO (Ptr AnnotMapping) + +{- | +Creates a new 'GI.Poppler.Structs.AnnotMapping.AnnotMapping' +-} +annotMappingNew :: + (B.CallStack.HasCallStack, MonadIO m) => + m AnnotMapping + {- ^ __Returns:__ a new 'GI.Poppler.Structs.AnnotMapping.AnnotMapping', use 'GI.Poppler.Structs.AnnotMapping.annotMappingFree' to free it -} +annotMappingNew = liftIO $ do + result <- poppler_annot_mapping_new + checkUnexpectedReturnNULL "annotMappingNew" result + result' <- (wrapBoxed AnnotMapping) result + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method AnnotMapping::copy +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "mapping", argType = TInterface (Name {namespace = "Poppler", name = "AnnotMapping"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerAnnotMapping to copy", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "AnnotMapping"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_annot_mapping_copy" poppler_annot_mapping_copy :: + Ptr AnnotMapping -> -- mapping : TInterface (Name {namespace = "Poppler", name = "AnnotMapping"}) + IO (Ptr AnnotMapping) + +{- | +Creates a copy of /@mapping@/ +-} +annotMappingCopy :: + (B.CallStack.HasCallStack, MonadIO m) => + AnnotMapping + {- ^ /@mapping@/: a 'GI.Poppler.Structs.AnnotMapping.AnnotMapping' to copy -} + -> m AnnotMapping + {- ^ __Returns:__ a new allocated copy of /@mapping@/ -} +annotMappingCopy mapping = liftIO $ do + mapping' <- unsafeManagedPtrGetPtr mapping + result <- poppler_annot_mapping_copy mapping' + checkUnexpectedReturnNULL "annotMappingCopy" result + result' <- (wrapBoxed AnnotMapping) result + touchManagedPtr mapping + return result' + +#if ENABLE_OVERLOADING +data AnnotMappingCopyMethodInfo +instance (signature ~ (m AnnotMapping), MonadIO m) => O.MethodInfo AnnotMappingCopyMethodInfo AnnotMapping signature where + overloadedMethod _ = annotMappingCopy + +#endif + +-- method AnnotMapping::free +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "mapping", argType = TInterface (Name {namespace = "Poppler", name = "AnnotMapping"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerAnnotMapping", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_annot_mapping_free" poppler_annot_mapping_free :: + Ptr AnnotMapping -> -- mapping : TInterface (Name {namespace = "Poppler", name = "AnnotMapping"}) + IO () + +{- | +Frees the given 'GI.Poppler.Structs.AnnotMapping.AnnotMapping' +-} +annotMappingFree :: + (B.CallStack.HasCallStack, MonadIO m) => + AnnotMapping + {- ^ /@mapping@/: a 'GI.Poppler.Structs.AnnotMapping.AnnotMapping' -} + -> m () +annotMappingFree mapping = liftIO $ do + mapping' <- unsafeManagedPtrGetPtr mapping + poppler_annot_mapping_free mapping' + touchManagedPtr mapping + return () + +#if ENABLE_OVERLOADING +data AnnotMappingFreeMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo AnnotMappingFreeMethodInfo AnnotMapping signature where + overloadedMethod _ = annotMappingFree + +#endif + +#if ENABLE_OVERLOADING +type family ResolveAnnotMappingMethod (t :: Symbol) (o :: *) :: * where + ResolveAnnotMappingMethod "copy" o = AnnotMappingCopyMethodInfo + ResolveAnnotMappingMethod "free" o = AnnotMappingFreeMethodInfo + ResolveAnnotMappingMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveAnnotMappingMethod t AnnotMapping, O.MethodInfo info AnnotMapping p) => OL.IsLabel t (AnnotMapping -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + 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,32 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Poppler.Structs.AnnotMapping where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype AnnotMapping = AnnotMapping (ManagedPtr AnnotMapping) +instance BoxedObject AnnotMapping where +#if ENABLE_OVERLOADING +data AnnotMappingCopyMethodInfo +#endif +#if ENABLE_OVERLOADING +data AnnotMappingFreeMethodInfo +#endif 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,380 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +A 'GI.Poppler.Structs.Color.Color' describes a RGB color. Color components +are values between 0 and 65535 +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Poppler.Structs.Color + ( + +-- * Exported types + Color(..) , + newZeroColor , + noColor , + + + -- * Methods +-- ** copy #method:copy# + +#if ENABLE_OVERLOADING + ColorCopyMethodInfo , +#endif + colorCopy , + + +-- ** free #method:free# + +#if ENABLE_OVERLOADING + ColorFreeMethodInfo , +#endif + colorFree , + + +-- ** new #method:new# + + colorNew , + + + + + -- * Properties +-- ** blue #attr:blue# +{- | the blue component of color +-} +#if ENABLE_OVERLOADING + color_blue , +#endif + getColorBlue , + setColorBlue , + + +-- ** green #attr:green# +{- | the green component of color +-} +#if ENABLE_OVERLOADING + color_green , +#endif + getColorGreen , + setColorGreen , + + +-- ** red #attr:red# +{- | the red component of color +-} +#if ENABLE_OVERLOADING + color_red , +#endif + getColorRed , + setColorRed , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + + +-- | Memory-managed wrapper type. +newtype Color = Color (ManagedPtr 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 + +-- | Construct a `Color` struct initialized to zero. +newZeroColor :: MonadIO m => m Color +newZeroColor = liftIO $ callocBoxedBytes 6 >>= wrapBoxed Color + +instance tag ~ 'AttrSet => Constructible Color tag where + new _ attrs = do + o <- newZeroColor + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `Color`. +noColor :: Maybe Color +noColor = Nothing + +{- | +Get the value of the “@red@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' color #red +@ +-} +getColorRed :: MonadIO m => Color -> m Word16 +getColorRed s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO Word16 + return val + +{- | +Set the value of the “@red@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' color [ #red 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setColorRed :: MonadIO m => Color -> Word16 -> m () +setColorRed s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 0) (val :: Word16) + +#if ENABLE_OVERLOADING +data ColorRedFieldInfo +instance AttrInfo ColorRedFieldInfo where + type AttrAllowedOps ColorRedFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint ColorRedFieldInfo = (~) Word16 + type AttrBaseTypeConstraint ColorRedFieldInfo = (~) Color + type AttrGetType ColorRedFieldInfo = Word16 + type AttrLabel ColorRedFieldInfo = "red" + type AttrOrigin ColorRedFieldInfo = Color + attrGet _ = getColorRed + attrSet _ = setColorRed + attrConstruct = undefined + attrClear _ = undefined + +color_red :: AttrLabelProxy "red" +color_red = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@green@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' color #green +@ +-} +getColorGreen :: MonadIO m => Color -> m Word16 +getColorGreen s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 2) :: IO Word16 + return val + +{- | +Set the value of the “@green@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' color [ #green 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setColorGreen :: MonadIO m => Color -> Word16 -> m () +setColorGreen s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 2) (val :: Word16) + +#if ENABLE_OVERLOADING +data ColorGreenFieldInfo +instance AttrInfo ColorGreenFieldInfo where + type AttrAllowedOps ColorGreenFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint ColorGreenFieldInfo = (~) Word16 + type AttrBaseTypeConstraint ColorGreenFieldInfo = (~) Color + type AttrGetType ColorGreenFieldInfo = Word16 + type AttrLabel ColorGreenFieldInfo = "green" + type AttrOrigin ColorGreenFieldInfo = Color + attrGet _ = getColorGreen + attrSet _ = setColorGreen + attrConstruct = undefined + attrClear _ = undefined + +color_green :: AttrLabelProxy "green" +color_green = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@blue@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' color #blue +@ +-} +getColorBlue :: MonadIO m => Color -> m Word16 +getColorBlue s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 4) :: IO Word16 + return val + +{- | +Set the value of the “@blue@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' color [ #blue 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setColorBlue :: MonadIO m => Color -> Word16 -> m () +setColorBlue s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 4) (val :: Word16) + +#if ENABLE_OVERLOADING +data ColorBlueFieldInfo +instance AttrInfo ColorBlueFieldInfo where + type AttrAllowedOps ColorBlueFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint ColorBlueFieldInfo = (~) Word16 + type AttrBaseTypeConstraint ColorBlueFieldInfo = (~) Color + type AttrGetType ColorBlueFieldInfo = Word16 + type AttrLabel ColorBlueFieldInfo = "blue" + type AttrOrigin ColorBlueFieldInfo = Color + attrGet _ = getColorBlue + attrSet _ = setColorBlue + attrConstruct = undefined + attrClear _ = undefined + +color_blue :: AttrLabelProxy "blue" +color_blue = AttrLabelProxy + +#endif + + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList Color +type instance O.AttributeList Color = ColorAttributeList +type ColorAttributeList = ('[ '("red", ColorRedFieldInfo), '("green", ColorGreenFieldInfo), '("blue", ColorBlueFieldInfo)] :: [(Symbol, *)]) +#endif + +-- method Color::new +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "Color"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_color_new" poppler_color_new :: + IO (Ptr Color) + +{- | +Creates a new 'GI.Poppler.Structs.Color.Color' +-} +colorNew :: + (B.CallStack.HasCallStack, MonadIO m) => + m Color + {- ^ __Returns:__ a new 'GI.Poppler.Structs.Color.Color', use 'GI.Poppler.Structs.Color.colorFree' to free it -} +colorNew = liftIO $ do + result <- poppler_color_new + checkUnexpectedReturnNULL "colorNew" result + result' <- (wrapBoxed Color) result + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method Color::copy +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "color", argType = TInterface (Name {namespace = "Poppler", name = "Color"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerColor to copy", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "Color"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_color_copy" poppler_color_copy :: + Ptr Color -> -- color : TInterface (Name {namespace = "Poppler", name = "Color"}) + IO (Ptr Color) + +{- | +Creates a copy of /@color@/ +-} +colorCopy :: + (B.CallStack.HasCallStack, MonadIO m) => + Color + {- ^ /@color@/: a 'GI.Poppler.Structs.Color.Color' to copy -} + -> m Color + {- ^ __Returns:__ a new allocated copy of /@color@/ -} +colorCopy color = liftIO $ do + color' <- unsafeManagedPtrGetPtr color + result <- poppler_color_copy color' + checkUnexpectedReturnNULL "colorCopy" result + result' <- (wrapBoxed Color) result + touchManagedPtr color + return result' + +#if ENABLE_OVERLOADING +data ColorCopyMethodInfo +instance (signature ~ (m Color), MonadIO m) => O.MethodInfo ColorCopyMethodInfo Color signature where + overloadedMethod _ = colorCopy + +#endif + +-- method Color::free +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "color", argType = TInterface (Name {namespace = "Poppler", name = "Color"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerColor", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_color_free" poppler_color_free :: + Ptr Color -> -- color : TInterface (Name {namespace = "Poppler", name = "Color"}) + IO () + +{- | +Frees the given 'GI.Poppler.Structs.Color.Color' +-} +colorFree :: + (B.CallStack.HasCallStack, MonadIO m) => + Color + {- ^ /@color@/: a 'GI.Poppler.Structs.Color.Color' -} + -> m () +colorFree color = liftIO $ do + color' <- unsafeManagedPtrGetPtr color + poppler_color_free color' + touchManagedPtr color + return () + +#if ENABLE_OVERLOADING +data ColorFreeMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo ColorFreeMethodInfo Color signature where + overloadedMethod _ = colorFree + +#endif + +#if ENABLE_OVERLOADING +type family ResolveColorMethod (t :: Symbol) (o :: *) :: * where + ResolveColorMethod "copy" o = ColorCopyMethodInfo + ResolveColorMethod "free" o = ColorFreeMethodInfo + ResolveColorMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveColorMethod t Color, O.MethodInfo info Color p) => OL.IsLabel t (Color -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + 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,32 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Poppler.Structs.Color where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype Color = Color (ManagedPtr Color) +instance BoxedObject Color where +#if ENABLE_OVERLOADING +data ColorCopyMethodInfo +#endif +#if ENABLE_OVERLOADING +data ColorFreeMethodInfo +#endif 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,824 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +Data structure for holding a destination + +Note that /@namedDest@/ is the string representation of the named +destination. This is the right form to pass to poppler functions, +e.g. 'GI.Poppler.Objects.Document.documentFindDest', but to get the destination as +it appears in the PDF itself, you need to convert it to a bytestring +with 'GI.Poppler.Functions.namedDestToBytestring' first. +Also note that /@namedDest@/ does not have a defined encoding and +is not in a form suitable to be displayed to the user. +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Poppler.Structs.Dest + ( + +-- * Exported types + Dest(..) , + newZeroDest , + noDest , + + + -- * Methods +-- ** copy #method:copy# + +#if ENABLE_OVERLOADING + DestCopyMethodInfo , +#endif + destCopy , + + +-- ** free #method:free# + +#if ENABLE_OVERLOADING + DestFreeMethodInfo , +#endif + destFree , + + + + + -- * Properties +-- ** bottom #attr:bottom# +{- | bottom coordinate +-} +#if ENABLE_OVERLOADING + dest_bottom , +#endif + getDestBottom , + setDestBottom , + + +-- ** changeLeft #attr:changeLeft# +{- | whether left coordinate should be changed +-} +#if ENABLE_OVERLOADING + dest_changeLeft , +#endif + getDestChangeLeft , + setDestChangeLeft , + + +-- ** changeTop #attr:changeTop# +{- | whether top coordinate should be changed +-} +#if ENABLE_OVERLOADING + dest_changeTop , +#endif + getDestChangeTop , + setDestChangeTop , + + +-- ** changeZoom #attr:changeZoom# +{- | whether scale factor should be changed +-} +#if ENABLE_OVERLOADING + dest_changeZoom , +#endif + getDestChangeZoom , + setDestChangeZoom , + + +-- ** left #attr:left# +{- | left coordinate +-} +#if ENABLE_OVERLOADING + dest_left , +#endif + getDestLeft , + setDestLeft , + + +-- ** namedDest #attr:namedDest# +{- | name of the destination (@/POPPLER_DEST_NAMED/@ only) +-} + clearDestNamedDest , +#if ENABLE_OVERLOADING + dest_namedDest , +#endif + getDestNamedDest , + setDestNamedDest , + + +-- ** pageNum #attr:pageNum# +{- | page number +-} +#if ENABLE_OVERLOADING + dest_pageNum , +#endif + getDestPageNum , + setDestPageNum , + + +-- ** right #attr:right# +{- | right coordinate +-} +#if ENABLE_OVERLOADING + dest_right , +#endif + getDestRight , + setDestRight , + + +-- ** top #attr:top# +{- | top coordinate +-} +#if ENABLE_OVERLOADING + dest_top , +#endif + getDestTop , + setDestTop , + + +-- ** type #attr:type# +{- | type of destination +-} +#if ENABLE_OVERLOADING + dest_type , +#endif + getDestType , + setDestType , + + +-- ** zoom #attr:zoom# +{- | scale factor +-} +#if ENABLE_OVERLOADING + dest_zoom , +#endif + getDestZoom , + setDestZoom , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import {-# SOURCE #-} qualified GI.Poppler.Enums as Poppler.Enums + +-- | Memory-managed wrapper type. +newtype Dest = Dest (ManagedPtr 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 + +-- | Construct a `Dest` struct initialized to zero. +newZeroDest :: MonadIO m => m Dest +newZeroDest = liftIO $ callocBoxedBytes 72 >>= wrapBoxed Dest + +instance tag ~ 'AttrSet => Constructible Dest tag where + new _ attrs = do + o <- newZeroDest + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `Dest`. +noDest :: Maybe Dest +noDest = Nothing + +{- | +Get the value of the “@type@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' dest #type +@ +-} +getDestType :: MonadIO m => Dest -> m Poppler.Enums.DestType +getDestType s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO CUInt + let val' = (toEnum . fromIntegral) val + return val' + +{- | +Set the value of the “@type@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' dest [ #type 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setDestType :: MonadIO m => Dest -> Poppler.Enums.DestType -> m () +setDestType s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = (fromIntegral . fromEnum) val + poke (ptr `plusPtr` 0) (val' :: CUInt) + +#if ENABLE_OVERLOADING +data DestTypeFieldInfo +instance AttrInfo DestTypeFieldInfo where + type AttrAllowedOps DestTypeFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint DestTypeFieldInfo = (~) Poppler.Enums.DestType + type AttrBaseTypeConstraint DestTypeFieldInfo = (~) Dest + type AttrGetType DestTypeFieldInfo = Poppler.Enums.DestType + type AttrLabel DestTypeFieldInfo = "type" + type AttrOrigin DestTypeFieldInfo = Dest + attrGet _ = getDestType + attrSet _ = setDestType + attrConstruct = undefined + attrClear _ = undefined + +dest_type :: AttrLabelProxy "type" +dest_type = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@page_num@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' dest #pageNum +@ +-} +getDestPageNum :: MonadIO m => Dest -> m Int32 +getDestPageNum s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 4) :: IO Int32 + return val + +{- | +Set the value of the “@page_num@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' dest [ #pageNum 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setDestPageNum :: MonadIO m => Dest -> Int32 -> m () +setDestPageNum s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 4) (val :: Int32) + +#if ENABLE_OVERLOADING +data DestPageNumFieldInfo +instance AttrInfo DestPageNumFieldInfo where + type AttrAllowedOps DestPageNumFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint DestPageNumFieldInfo = (~) Int32 + type AttrBaseTypeConstraint DestPageNumFieldInfo = (~) Dest + type AttrGetType DestPageNumFieldInfo = Int32 + type AttrLabel DestPageNumFieldInfo = "page_num" + type AttrOrigin DestPageNumFieldInfo = Dest + attrGet _ = getDestPageNum + attrSet _ = setDestPageNum + attrConstruct = undefined + attrClear _ = undefined + +dest_pageNum :: AttrLabelProxy "pageNum" +dest_pageNum = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@left@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' dest #left +@ +-} +getDestLeft :: MonadIO m => Dest -> m Double +getDestLeft s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 8) :: IO CDouble + let val' = realToFrac val + return val' + +{- | +Set the value of the “@left@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' dest [ #left 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setDestLeft :: MonadIO m => Dest -> Double -> m () +setDestLeft s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = realToFrac val + poke (ptr `plusPtr` 8) (val' :: CDouble) + +#if ENABLE_OVERLOADING +data DestLeftFieldInfo +instance AttrInfo DestLeftFieldInfo where + type AttrAllowedOps DestLeftFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint DestLeftFieldInfo = (~) Double + type AttrBaseTypeConstraint DestLeftFieldInfo = (~) Dest + type AttrGetType DestLeftFieldInfo = Double + type AttrLabel DestLeftFieldInfo = "left" + type AttrOrigin DestLeftFieldInfo = Dest + attrGet _ = getDestLeft + attrSet _ = setDestLeft + attrConstruct = undefined + attrClear _ = undefined + +dest_left :: AttrLabelProxy "left" +dest_left = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@bottom@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' dest #bottom +@ +-} +getDestBottom :: MonadIO m => Dest -> m Double +getDestBottom s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 16) :: IO CDouble + let val' = realToFrac val + return val' + +{- | +Set the value of the “@bottom@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' dest [ #bottom 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setDestBottom :: MonadIO m => Dest -> Double -> m () +setDestBottom s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = realToFrac val + poke (ptr `plusPtr` 16) (val' :: CDouble) + +#if ENABLE_OVERLOADING +data DestBottomFieldInfo +instance AttrInfo DestBottomFieldInfo where + type AttrAllowedOps DestBottomFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint DestBottomFieldInfo = (~) Double + type AttrBaseTypeConstraint DestBottomFieldInfo = (~) Dest + type AttrGetType DestBottomFieldInfo = Double + type AttrLabel DestBottomFieldInfo = "bottom" + type AttrOrigin DestBottomFieldInfo = Dest + attrGet _ = getDestBottom + attrSet _ = setDestBottom + attrConstruct = undefined + attrClear _ = undefined + +dest_bottom :: AttrLabelProxy "bottom" +dest_bottom = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@right@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' dest #right +@ +-} +getDestRight :: MonadIO m => Dest -> m Double +getDestRight s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 24) :: IO CDouble + let val' = realToFrac val + return val' + +{- | +Set the value of the “@right@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' dest [ #right 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setDestRight :: MonadIO m => Dest -> Double -> m () +setDestRight s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = realToFrac val + poke (ptr `plusPtr` 24) (val' :: CDouble) + +#if ENABLE_OVERLOADING +data DestRightFieldInfo +instance AttrInfo DestRightFieldInfo where + type AttrAllowedOps DestRightFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint DestRightFieldInfo = (~) Double + type AttrBaseTypeConstraint DestRightFieldInfo = (~) Dest + type AttrGetType DestRightFieldInfo = Double + type AttrLabel DestRightFieldInfo = "right" + type AttrOrigin DestRightFieldInfo = Dest + attrGet _ = getDestRight + attrSet _ = setDestRight + attrConstruct = undefined + attrClear _ = undefined + +dest_right :: AttrLabelProxy "right" +dest_right = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@top@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' dest #top +@ +-} +getDestTop :: MonadIO m => Dest -> m Double +getDestTop s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 32) :: IO CDouble + let val' = realToFrac val + return val' + +{- | +Set the value of the “@top@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' dest [ #top 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setDestTop :: MonadIO m => Dest -> Double -> m () +setDestTop s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = realToFrac val + poke (ptr `plusPtr` 32) (val' :: CDouble) + +#if ENABLE_OVERLOADING +data DestTopFieldInfo +instance AttrInfo DestTopFieldInfo where + type AttrAllowedOps DestTopFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint DestTopFieldInfo = (~) Double + type AttrBaseTypeConstraint DestTopFieldInfo = (~) Dest + type AttrGetType DestTopFieldInfo = Double + type AttrLabel DestTopFieldInfo = "top" + type AttrOrigin DestTopFieldInfo = Dest + attrGet _ = getDestTop + attrSet _ = setDestTop + attrConstruct = undefined + attrClear _ = undefined + +dest_top :: AttrLabelProxy "top" +dest_top = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@zoom@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' dest #zoom +@ +-} +getDestZoom :: MonadIO m => Dest -> m Double +getDestZoom s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 40) :: IO CDouble + let val' = realToFrac val + return val' + +{- | +Set the value of the “@zoom@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' dest [ #zoom 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setDestZoom :: MonadIO m => Dest -> Double -> m () +setDestZoom s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = realToFrac val + poke (ptr `plusPtr` 40) (val' :: CDouble) + +#if ENABLE_OVERLOADING +data DestZoomFieldInfo +instance AttrInfo DestZoomFieldInfo where + type AttrAllowedOps DestZoomFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint DestZoomFieldInfo = (~) Double + type AttrBaseTypeConstraint DestZoomFieldInfo = (~) Dest + type AttrGetType DestZoomFieldInfo = Double + type AttrLabel DestZoomFieldInfo = "zoom" + type AttrOrigin DestZoomFieldInfo = Dest + attrGet _ = getDestZoom + attrSet _ = setDestZoom + attrConstruct = undefined + attrClear _ = undefined + +dest_zoom :: AttrLabelProxy "zoom" +dest_zoom = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@named_dest@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' dest #namedDest +@ +-} +getDestNamedDest :: MonadIO m => Dest -> m (Maybe T.Text) +getDestNamedDest s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 48) :: IO CString + result <- SP.convertIfNonNull val $ \val' -> do + val'' <- cstringToText val' + return val'' + return result + +{- | +Set the value of the “@named_dest@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' dest [ #namedDest 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setDestNamedDest :: MonadIO m => Dest -> CString -> m () +setDestNamedDest s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 48) (val :: CString) + +{- | +Set the value of the “@named_dest@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #namedDest +@ +-} +clearDestNamedDest :: MonadIO m => Dest -> m () +clearDestNamedDest s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 48) (FP.nullPtr :: CString) + +#if ENABLE_OVERLOADING +data DestNamedDestFieldInfo +instance AttrInfo DestNamedDestFieldInfo where + type AttrAllowedOps DestNamedDestFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint DestNamedDestFieldInfo = (~) CString + type AttrBaseTypeConstraint DestNamedDestFieldInfo = (~) Dest + type AttrGetType DestNamedDestFieldInfo = Maybe T.Text + type AttrLabel DestNamedDestFieldInfo = "named_dest" + type AttrOrigin DestNamedDestFieldInfo = Dest + attrGet _ = getDestNamedDest + attrSet _ = setDestNamedDest + attrConstruct = undefined + attrClear _ = clearDestNamedDest + +dest_namedDest :: AttrLabelProxy "namedDest" +dest_namedDest = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@change_left@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' dest #changeLeft +@ +-} +getDestChangeLeft :: MonadIO m => Dest -> m Word32 +getDestChangeLeft s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 56) :: IO Word32 + return val + +{- | +Set the value of the “@change_left@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' dest [ #changeLeft 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setDestChangeLeft :: MonadIO m => Dest -> Word32 -> m () +setDestChangeLeft s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 56) (val :: Word32) + +#if ENABLE_OVERLOADING +data DestChangeLeftFieldInfo +instance AttrInfo DestChangeLeftFieldInfo where + type AttrAllowedOps DestChangeLeftFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint DestChangeLeftFieldInfo = (~) Word32 + type AttrBaseTypeConstraint DestChangeLeftFieldInfo = (~) Dest + type AttrGetType DestChangeLeftFieldInfo = Word32 + type AttrLabel DestChangeLeftFieldInfo = "change_left" + type AttrOrigin DestChangeLeftFieldInfo = Dest + attrGet _ = getDestChangeLeft + attrSet _ = setDestChangeLeft + attrConstruct = undefined + attrClear _ = undefined + +dest_changeLeft :: AttrLabelProxy "changeLeft" +dest_changeLeft = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@change_top@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' dest #changeTop +@ +-} +getDestChangeTop :: MonadIO m => Dest -> m Word32 +getDestChangeTop s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 60) :: IO Word32 + return val + +{- | +Set the value of the “@change_top@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' dest [ #changeTop 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setDestChangeTop :: MonadIO m => Dest -> Word32 -> m () +setDestChangeTop s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 60) (val :: Word32) + +#if ENABLE_OVERLOADING +data DestChangeTopFieldInfo +instance AttrInfo DestChangeTopFieldInfo where + type AttrAllowedOps DestChangeTopFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint DestChangeTopFieldInfo = (~) Word32 + type AttrBaseTypeConstraint DestChangeTopFieldInfo = (~) Dest + type AttrGetType DestChangeTopFieldInfo = Word32 + type AttrLabel DestChangeTopFieldInfo = "change_top" + type AttrOrigin DestChangeTopFieldInfo = Dest + attrGet _ = getDestChangeTop + attrSet _ = setDestChangeTop + attrConstruct = undefined + attrClear _ = undefined + +dest_changeTop :: AttrLabelProxy "changeTop" +dest_changeTop = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@change_zoom@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' dest #changeZoom +@ +-} +getDestChangeZoom :: MonadIO m => Dest -> m Word32 +getDestChangeZoom s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 64) :: IO Word32 + return val + +{- | +Set the value of the “@change_zoom@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' dest [ #changeZoom 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setDestChangeZoom :: MonadIO m => Dest -> Word32 -> m () +setDestChangeZoom s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 64) (val :: Word32) + +#if ENABLE_OVERLOADING +data DestChangeZoomFieldInfo +instance AttrInfo DestChangeZoomFieldInfo where + type AttrAllowedOps DestChangeZoomFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint DestChangeZoomFieldInfo = (~) Word32 + type AttrBaseTypeConstraint DestChangeZoomFieldInfo = (~) Dest + type AttrGetType DestChangeZoomFieldInfo = Word32 + type AttrLabel DestChangeZoomFieldInfo = "change_zoom" + type AttrOrigin DestChangeZoomFieldInfo = Dest + attrGet _ = getDestChangeZoom + attrSet _ = setDestChangeZoom + attrConstruct = undefined + attrClear _ = undefined + +dest_changeZoom :: AttrLabelProxy "changeZoom" +dest_changeZoom = AttrLabelProxy + +#endif + + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList Dest +type instance O.AttributeList Dest = DestAttributeList +type DestAttributeList = ('[ '("type", DestTypeFieldInfo), '("pageNum", DestPageNumFieldInfo), '("left", DestLeftFieldInfo), '("bottom", DestBottomFieldInfo), '("right", DestRightFieldInfo), '("top", DestTopFieldInfo), '("zoom", DestZoomFieldInfo), '("namedDest", DestNamedDestFieldInfo), '("changeLeft", DestChangeLeftFieldInfo), '("changeTop", DestChangeTopFieldInfo), '("changeZoom", DestChangeZoomFieldInfo)] :: [(Symbol, *)]) +#endif + +-- method Dest::copy +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "dest", argType = TInterface (Name {namespace = "Poppler", name = "Dest"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerDest", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "Dest"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_dest_copy" poppler_dest_copy :: + Ptr Dest -> -- dest : TInterface (Name {namespace = "Poppler", name = "Dest"}) + IO (Ptr Dest) + +{- | +Copies /@dest@/, creating an identical 'GI.Poppler.Structs.Dest.Dest'. +-} +destCopy :: + (B.CallStack.HasCallStack, MonadIO m) => + Dest + {- ^ /@dest@/: a 'GI.Poppler.Structs.Dest.Dest' -} + -> m Dest + {- ^ __Returns:__ a new destination identical to /@dest@/ -} +destCopy dest = liftIO $ do + dest' <- unsafeManagedPtrGetPtr dest + result <- poppler_dest_copy dest' + checkUnexpectedReturnNULL "destCopy" result + result' <- (wrapBoxed Dest) result + touchManagedPtr dest + return result' + +#if ENABLE_OVERLOADING +data DestCopyMethodInfo +instance (signature ~ (m Dest), MonadIO m) => O.MethodInfo DestCopyMethodInfo Dest signature where + overloadedMethod _ = destCopy + +#endif + +-- method Dest::free +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "dest", argType = TInterface (Name {namespace = "Poppler", name = "Dest"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerDest", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_dest_free" poppler_dest_free :: + Ptr Dest -> -- dest : TInterface (Name {namespace = "Poppler", name = "Dest"}) + IO () + +{- | +Frees /@dest@/ +-} +destFree :: + (B.CallStack.HasCallStack, MonadIO m) => + Dest + {- ^ /@dest@/: a 'GI.Poppler.Structs.Dest.Dest' -} + -> m () +destFree dest = liftIO $ do + dest' <- unsafeManagedPtrGetPtr dest + poppler_dest_free dest' + touchManagedPtr dest + return () + +#if ENABLE_OVERLOADING +data DestFreeMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo DestFreeMethodInfo Dest signature where + overloadedMethod _ = destFree + +#endif + +#if ENABLE_OVERLOADING +type family ResolveDestMethod (t :: Symbol) (o :: *) :: * where + ResolveDestMethod "copy" o = DestCopyMethodInfo + ResolveDestMethod "free" o = DestFreeMethodInfo + ResolveDestMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveDestMethod t Dest, O.MethodInfo info Dest p) => OL.IsLabel t (Dest -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + 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,32 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Poppler.Structs.Dest where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype Dest = Dest (ManagedPtr Dest) +instance BoxedObject Dest where +#if ENABLE_OVERLOADING +data DestCopyMethodInfo +#endif +#if ENABLE_OVERLOADING +data DestFreeMethodInfo +#endif 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,575 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Poppler.Structs.FontsIter + ( + +-- * Exported types + FontsIter(..) , + noFontsIter , + + + -- * Methods +-- ** copy #method:copy# + +#if ENABLE_OVERLOADING + FontsIterCopyMethodInfo , +#endif + fontsIterCopy , + + +-- ** free #method:free# + +#if ENABLE_OVERLOADING + FontsIterFreeMethodInfo , +#endif + fontsIterFree , + + +-- ** getEncoding #method:getEncoding# + +#if ENABLE_OVERLOADING + FontsIterGetEncodingMethodInfo , +#endif + fontsIterGetEncoding , + + +-- ** getFileName #method:getFileName# + +#if ENABLE_OVERLOADING + FontsIterGetFileNameMethodInfo , +#endif + fontsIterGetFileName , + + +-- ** getFontType #method:getFontType# + +#if ENABLE_OVERLOADING + FontsIterGetFontTypeMethodInfo , +#endif + fontsIterGetFontType , + + +-- ** getFullName #method:getFullName# + +#if ENABLE_OVERLOADING + FontsIterGetFullNameMethodInfo , +#endif + fontsIterGetFullName , + + +-- ** getName #method:getName# + +#if ENABLE_OVERLOADING + FontsIterGetNameMethodInfo , +#endif + fontsIterGetName , + + +-- ** getSubstituteName #method:getSubstituteName# + +#if ENABLE_OVERLOADING + FontsIterGetSubstituteNameMethodInfo , +#endif + fontsIterGetSubstituteName , + + +-- ** isEmbedded #method:isEmbedded# + +#if ENABLE_OVERLOADING + FontsIterIsEmbeddedMethodInfo , +#endif + fontsIterIsEmbedded , + + +-- ** isSubset #method:isSubset# + +#if ENABLE_OVERLOADING + FontsIterIsSubsetMethodInfo , +#endif + fontsIterIsSubset , + + +-- ** next #method:next# + +#if ENABLE_OVERLOADING + FontsIterNextMethodInfo , +#endif + fontsIterNext , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import {-# SOURCE #-} qualified GI.Poppler.Enums as Poppler.Enums + +-- | Memory-managed wrapper type. +newtype FontsIter = FontsIter (ManagedPtr 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 + +-- | A convenience alias for `Nothing` :: `Maybe` `FontsIter`. +noFontsIter :: Maybe FontsIter +noFontsIter = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList FontsIter +type instance O.AttributeList FontsIter = FontsIterAttributeList +type FontsIterAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method FontsIter::copy +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "iter", argType = TInterface (Name {namespace = "Poppler", name = "FontsIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerFontsIter to copy", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "FontsIter"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_fonts_iter_copy" poppler_fonts_iter_copy :: + Ptr FontsIter -> -- iter : TInterface (Name {namespace = "Poppler", name = "FontsIter"}) + IO (Ptr FontsIter) + +{- | +Creates a copy of /@iter@/ +-} +fontsIterCopy :: + (B.CallStack.HasCallStack, MonadIO m) => + FontsIter + {- ^ /@iter@/: a 'GI.Poppler.Structs.FontsIter.FontsIter' to copy -} + -> m FontsIter + {- ^ __Returns:__ a new allocated copy of /@iter@/ -} +fontsIterCopy iter = liftIO $ do + iter' <- unsafeManagedPtrGetPtr iter + result <- poppler_fonts_iter_copy iter' + checkUnexpectedReturnNULL "fontsIterCopy" result + result' <- (wrapBoxed FontsIter) result + touchManagedPtr iter + return result' + +#if ENABLE_OVERLOADING +data FontsIterCopyMethodInfo +instance (signature ~ (m FontsIter), MonadIO m) => O.MethodInfo FontsIterCopyMethodInfo FontsIter signature where + overloadedMethod _ = fontsIterCopy + +#endif + +-- method FontsIter::free +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "iter", argType = TInterface (Name {namespace = "Poppler", name = "FontsIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerFontsIter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_fonts_iter_free" poppler_fonts_iter_free :: + Ptr FontsIter -> -- iter : TInterface (Name {namespace = "Poppler", name = "FontsIter"}) + IO () + +{- | +Frees the given 'GI.Poppler.Structs.FontsIter.FontsIter' +-} +fontsIterFree :: + (B.CallStack.HasCallStack, MonadIO m) => + FontsIter + {- ^ /@iter@/: a 'GI.Poppler.Structs.FontsIter.FontsIter' -} + -> m () +fontsIterFree iter = liftIO $ do + iter' <- unsafeManagedPtrGetPtr iter + poppler_fonts_iter_free iter' + touchManagedPtr iter + return () + +#if ENABLE_OVERLOADING +data FontsIterFreeMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo FontsIterFreeMethodInfo FontsIter signature where + overloadedMethod _ = fontsIterFree + +#endif + +-- method FontsIter::get_encoding +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "iter", argType = TInterface (Name {namespace = "Poppler", name = "FontsIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerFontsIter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_fonts_iter_get_encoding" poppler_fonts_iter_get_encoding :: + Ptr FontsIter -> -- iter : TInterface (Name {namespace = "Poppler", name = "FontsIter"}) + IO CString + +{- | +Returns the encoding of the font associated with /@iter@/ + +/Since: 0.20/ +-} +fontsIterGetEncoding :: + (B.CallStack.HasCallStack, MonadIO m) => + FontsIter + {- ^ /@iter@/: a 'GI.Poppler.Structs.FontsIter.FontsIter' -} + -> m T.Text + {- ^ __Returns:__ the font encoding -} +fontsIterGetEncoding iter = liftIO $ do + iter' <- unsafeManagedPtrGetPtr iter + result <- poppler_fonts_iter_get_encoding iter' + checkUnexpectedReturnNULL "fontsIterGetEncoding" result + result' <- cstringToText result + touchManagedPtr iter + return result' + +#if ENABLE_OVERLOADING +data FontsIterGetEncodingMethodInfo +instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo FontsIterGetEncodingMethodInfo FontsIter signature where + overloadedMethod _ = fontsIterGetEncoding + +#endif + +-- method FontsIter::get_file_name +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "iter", argType = TInterface (Name {namespace = "Poppler", name = "FontsIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerFontsIter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_fonts_iter_get_file_name" poppler_fonts_iter_get_file_name :: + Ptr FontsIter -> -- iter : TInterface (Name {namespace = "Poppler", name = "FontsIter"}) + IO CString + +{- | +The filename of the font associated with /@iter@/ or 'Nothing' if +the font is embedded +-} +fontsIterGetFileName :: + (B.CallStack.HasCallStack, MonadIO m) => + FontsIter + {- ^ /@iter@/: a 'GI.Poppler.Structs.FontsIter.FontsIter' -} + -> m T.Text + {- ^ __Returns:__ the filename of the font or 'Nothing' if font is embedded -} +fontsIterGetFileName iter = liftIO $ do + iter' <- unsafeManagedPtrGetPtr iter + result <- poppler_fonts_iter_get_file_name iter' + checkUnexpectedReturnNULL "fontsIterGetFileName" result + result' <- cstringToText result + touchManagedPtr iter + return result' + +#if ENABLE_OVERLOADING +data FontsIterGetFileNameMethodInfo +instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo FontsIterGetFileNameMethodInfo FontsIter signature where + overloadedMethod _ = fontsIterGetFileName + +#endif + +-- method FontsIter::get_font_type +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "iter", argType = TInterface (Name {namespace = "Poppler", name = "FontsIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerFontsIter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "FontType"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_fonts_iter_get_font_type" poppler_fonts_iter_get_font_type :: + Ptr FontsIter -> -- iter : TInterface (Name {namespace = "Poppler", name = "FontsIter"}) + IO CUInt + +{- | +Returns the type of the font associated with /@iter@/ +-} +fontsIterGetFontType :: + (B.CallStack.HasCallStack, MonadIO m) => + FontsIter + {- ^ /@iter@/: a 'GI.Poppler.Structs.FontsIter.FontsIter' -} + -> m Poppler.Enums.FontType + {- ^ __Returns:__ the font type -} +fontsIterGetFontType iter = liftIO $ do + iter' <- unsafeManagedPtrGetPtr iter + result <- poppler_fonts_iter_get_font_type iter' + let result' = (toEnum . fromIntegral) result + touchManagedPtr iter + return result' + +#if ENABLE_OVERLOADING +data FontsIterGetFontTypeMethodInfo +instance (signature ~ (m Poppler.Enums.FontType), MonadIO m) => O.MethodInfo FontsIterGetFontTypeMethodInfo FontsIter signature where + overloadedMethod _ = fontsIterGetFontType + +#endif + +-- method FontsIter::get_full_name +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "iter", argType = TInterface (Name {namespace = "Poppler", name = "FontsIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerFontsIter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_fonts_iter_get_full_name" poppler_fonts_iter_get_full_name :: + Ptr FontsIter -> -- iter : TInterface (Name {namespace = "Poppler", name = "FontsIter"}) + IO CString + +{- | +Returns the full name of the font associated with /@iter@/ +-} +fontsIterGetFullName :: + (B.CallStack.HasCallStack, MonadIO m) => + FontsIter + {- ^ /@iter@/: a 'GI.Poppler.Structs.FontsIter.FontsIter' -} + -> m T.Text + {- ^ __Returns:__ the font full name -} +fontsIterGetFullName iter = liftIO $ do + iter' <- unsafeManagedPtrGetPtr iter + result <- poppler_fonts_iter_get_full_name iter' + checkUnexpectedReturnNULL "fontsIterGetFullName" result + result' <- cstringToText result + touchManagedPtr iter + return result' + +#if ENABLE_OVERLOADING +data FontsIterGetFullNameMethodInfo +instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo FontsIterGetFullNameMethodInfo FontsIter signature where + overloadedMethod _ = fontsIterGetFullName + +#endif + +-- method FontsIter::get_name +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "iter", argType = TInterface (Name {namespace = "Poppler", name = "FontsIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerFontsIter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_fonts_iter_get_name" poppler_fonts_iter_get_name :: + Ptr FontsIter -> -- iter : TInterface (Name {namespace = "Poppler", name = "FontsIter"}) + IO CString + +{- | +Returns the name of the font associated with /@iter@/ +-} +fontsIterGetName :: + (B.CallStack.HasCallStack, MonadIO m) => + FontsIter + {- ^ /@iter@/: a 'GI.Poppler.Structs.FontsIter.FontsIter' -} + -> m T.Text + {- ^ __Returns:__ the font name -} +fontsIterGetName iter = liftIO $ do + iter' <- unsafeManagedPtrGetPtr iter + result <- poppler_fonts_iter_get_name iter' + checkUnexpectedReturnNULL "fontsIterGetName" result + result' <- cstringToText result + touchManagedPtr iter + return result' + +#if ENABLE_OVERLOADING +data FontsIterGetNameMethodInfo +instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo FontsIterGetNameMethodInfo FontsIter signature where + overloadedMethod _ = fontsIterGetName + +#endif + +-- method FontsIter::get_substitute_name +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "iter", argType = TInterface (Name {namespace = "Poppler", name = "FontsIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerFontsIter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_fonts_iter_get_substitute_name" poppler_fonts_iter_get_substitute_name :: + Ptr FontsIter -> -- iter : TInterface (Name {namespace = "Poppler", name = "FontsIter"}) + IO CString + +{- | +The name of the substitute font of the font associated with /@iter@/ or 'Nothing' if +the font is embedded + +/Since: 0.20/ +-} +fontsIterGetSubstituteName :: + (B.CallStack.HasCallStack, MonadIO m) => + FontsIter + {- ^ /@iter@/: a 'GI.Poppler.Structs.FontsIter.FontsIter' -} + -> m T.Text + {- ^ __Returns:__ the name of the substitute font or 'Nothing' if font is embedded -} +fontsIterGetSubstituteName iter = liftIO $ do + iter' <- unsafeManagedPtrGetPtr iter + result <- poppler_fonts_iter_get_substitute_name iter' + checkUnexpectedReturnNULL "fontsIterGetSubstituteName" result + result' <- cstringToText result + touchManagedPtr iter + return result' + +#if ENABLE_OVERLOADING +data FontsIterGetSubstituteNameMethodInfo +instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo FontsIterGetSubstituteNameMethodInfo FontsIter signature where + overloadedMethod _ = fontsIterGetSubstituteName + +#endif + +-- method FontsIter::is_embedded +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "iter", argType = TInterface (Name {namespace = "Poppler", name = "FontsIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerFontsIter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_fonts_iter_is_embedded" poppler_fonts_iter_is_embedded :: + Ptr FontsIter -> -- iter : TInterface (Name {namespace = "Poppler", name = "FontsIter"}) + IO CInt + +{- | +Returns whether the font associated with /@iter@/ is embedded in the document +-} +fontsIterIsEmbedded :: + (B.CallStack.HasCallStack, MonadIO m) => + FontsIter + {- ^ /@iter@/: a 'GI.Poppler.Structs.FontsIter.FontsIter' -} + -> m Bool + {- ^ __Returns:__ 'True' if font is embedded, 'False' otherwise -} +fontsIterIsEmbedded iter = liftIO $ do + iter' <- unsafeManagedPtrGetPtr iter + result <- poppler_fonts_iter_is_embedded iter' + let result' = (/= 0) result + touchManagedPtr iter + return result' + +#if ENABLE_OVERLOADING +data FontsIterIsEmbeddedMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo FontsIterIsEmbeddedMethodInfo FontsIter signature where + overloadedMethod _ = fontsIterIsEmbedded + +#endif + +-- method FontsIter::is_subset +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "iter", argType = TInterface (Name {namespace = "Poppler", name = "FontsIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerFontsIter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_fonts_iter_is_subset" poppler_fonts_iter_is_subset :: + Ptr FontsIter -> -- iter : TInterface (Name {namespace = "Poppler", name = "FontsIter"}) + IO CInt + +{- | +Returns whether the font associated with /@iter@/ is a subset of another font +-} +fontsIterIsSubset :: + (B.CallStack.HasCallStack, MonadIO m) => + FontsIter + {- ^ /@iter@/: a 'GI.Poppler.Structs.FontsIter.FontsIter' -} + -> m Bool + {- ^ __Returns:__ 'True' if font is a subset, 'False' otherwise -} +fontsIterIsSubset iter = liftIO $ do + iter' <- unsafeManagedPtrGetPtr iter + result <- poppler_fonts_iter_is_subset iter' + let result' = (/= 0) result + touchManagedPtr iter + return result' + +#if ENABLE_OVERLOADING +data FontsIterIsSubsetMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo FontsIterIsSubsetMethodInfo FontsIter signature where + overloadedMethod _ = fontsIterIsSubset + +#endif + +-- method FontsIter::next +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "iter", argType = TInterface (Name {namespace = "Poppler", name = "FontsIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerFontsIter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_fonts_iter_next" poppler_fonts_iter_next :: + Ptr FontsIter -> -- iter : TInterface (Name {namespace = "Poppler", name = "FontsIter"}) + IO CInt + +{- | +Sets /@iter@/ to point to the next font +-} +fontsIterNext :: + (B.CallStack.HasCallStack, MonadIO m) => + FontsIter + {- ^ /@iter@/: a 'GI.Poppler.Structs.FontsIter.FontsIter' -} + -> m Bool + {- ^ __Returns:__ 'True', if /@iter@/ was set to the next font -} +fontsIterNext iter = liftIO $ do + iter' <- unsafeManagedPtrGetPtr iter + result <- poppler_fonts_iter_next iter' + let result' = (/= 0) result + touchManagedPtr iter + return result' + +#if ENABLE_OVERLOADING +data FontsIterNextMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo FontsIterNextMethodInfo FontsIter signature where + overloadedMethod _ = fontsIterNext + +#endif + +#if ENABLE_OVERLOADING +type family ResolveFontsIterMethod (t :: Symbol) (o :: *) :: * where + ResolveFontsIterMethod "copy" o = FontsIterCopyMethodInfo + ResolveFontsIterMethod "free" o = FontsIterFreeMethodInfo + ResolveFontsIterMethod "isEmbedded" o = FontsIterIsEmbeddedMethodInfo + ResolveFontsIterMethod "isSubset" o = FontsIterIsSubsetMethodInfo + ResolveFontsIterMethod "next" o = FontsIterNextMethodInfo + ResolveFontsIterMethod "getEncoding" o = FontsIterGetEncodingMethodInfo + ResolveFontsIterMethod "getFileName" o = FontsIterGetFileNameMethodInfo + ResolveFontsIterMethod "getFontType" o = FontsIterGetFontTypeMethodInfo + ResolveFontsIterMethod "getFullName" o = FontsIterGetFullNameMethodInfo + ResolveFontsIterMethod "getName" o = FontsIterGetNameMethodInfo + ResolveFontsIterMethod "getSubstituteName" o = FontsIterGetSubstituteNameMethodInfo + ResolveFontsIterMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveFontsIterMethod t FontsIter, O.MethodInfo info FontsIter p) => OL.IsLabel t (FontsIter -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + 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,59 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Poppler.Structs.FontsIter where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype FontsIter = FontsIter (ManagedPtr FontsIter) +instance BoxedObject FontsIter where +#if ENABLE_OVERLOADING +data FontsIterCopyMethodInfo +#endif +#if ENABLE_OVERLOADING +data FontsIterFreeMethodInfo +#endif +#if ENABLE_OVERLOADING +data FontsIterGetEncodingMethodInfo +#endif +#if ENABLE_OVERLOADING +data FontsIterGetFileNameMethodInfo +#endif +#if ENABLE_OVERLOADING +data FontsIterGetFontTypeMethodInfo +#endif +#if ENABLE_OVERLOADING +data FontsIterGetFullNameMethodInfo +#endif +#if ENABLE_OVERLOADING +data FontsIterGetNameMethodInfo +#endif +#if ENABLE_OVERLOADING +data FontsIterGetSubstituteNameMethodInfo +#endif +#if ENABLE_OVERLOADING +data FontsIterIsEmbeddedMethodInfo +#endif +#if ENABLE_OVERLOADING +data FontsIterIsSubsetMethodInfo +#endif +#if ENABLE_OVERLOADING +data FontsIterNextMethodInfo +#endif 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,331 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +A 'GI.Poppler.Structs.FormFieldMapping.FormFieldMapping' structure represents the location +of /@field@/ on the page +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Poppler.Structs.FormFieldMapping + ( + +-- * Exported types + FormFieldMapping(..) , + newZeroFormFieldMapping , + noFormFieldMapping , + + + -- * Methods +-- ** copy #method:copy# + +#if ENABLE_OVERLOADING + FormFieldMappingCopyMethodInfo , +#endif + formFieldMappingCopy , + + +-- ** free #method:free# + +#if ENABLE_OVERLOADING + FormFieldMappingFreeMethodInfo , +#endif + formFieldMappingFree , + + +-- ** new #method:new# + + formFieldMappingNew , + + + + + -- * Properties +-- ** area #attr:area# +{- | a 'GI.Poppler.Structs.Rectangle.Rectangle' representing an area of the page +-} +#if ENABLE_OVERLOADING + formFieldMapping_area , +#endif + getFormFieldMappingArea , + + +-- ** field #attr:field# +{- | a 'GI.Poppler.Objects.FormField.FormField' +-} + clearFormFieldMappingField , +#if ENABLE_OVERLOADING + formFieldMapping_field , +#endif + getFormFieldMappingField , + setFormFieldMappingField , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import {-# SOURCE #-} qualified GI.Poppler.Objects.FormField as Poppler.FormField +import {-# SOURCE #-} qualified GI.Poppler.Structs.Rectangle as Poppler.Rectangle + +-- | Memory-managed wrapper type. +newtype FormFieldMapping = FormFieldMapping (ManagedPtr 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 + +-- | Construct a `FormFieldMapping` struct initialized to zero. +newZeroFormFieldMapping :: MonadIO m => m FormFieldMapping +newZeroFormFieldMapping = liftIO $ callocBoxedBytes 40 >>= wrapBoxed FormFieldMapping + +instance tag ~ 'AttrSet => Constructible FormFieldMapping tag where + new _ attrs = do + o <- newZeroFormFieldMapping + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `FormFieldMapping`. +noFormFieldMapping :: Maybe FormFieldMapping +noFormFieldMapping = Nothing + +{- | +Get the value of the “@area@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' formFieldMapping #area +@ +-} +getFormFieldMappingArea :: MonadIO m => FormFieldMapping -> m Poppler.Rectangle.Rectangle +getFormFieldMappingArea s = liftIO $ withManagedPtr s $ \ptr -> do + let val = ptr `plusPtr` 0 :: (Ptr Poppler.Rectangle.Rectangle) + val' <- (newBoxed Poppler.Rectangle.Rectangle) val + return val' + +#if ENABLE_OVERLOADING +data FormFieldMappingAreaFieldInfo +instance AttrInfo FormFieldMappingAreaFieldInfo where + type AttrAllowedOps FormFieldMappingAreaFieldInfo = '[ 'AttrGet] + type AttrSetTypeConstraint FormFieldMappingAreaFieldInfo = (~) (Ptr Poppler.Rectangle.Rectangle) + type AttrBaseTypeConstraint FormFieldMappingAreaFieldInfo = (~) FormFieldMapping + type AttrGetType FormFieldMappingAreaFieldInfo = Poppler.Rectangle.Rectangle + type AttrLabel FormFieldMappingAreaFieldInfo = "area" + type AttrOrigin FormFieldMappingAreaFieldInfo = FormFieldMapping + attrGet _ = getFormFieldMappingArea + attrSet _ = undefined + attrConstruct = undefined + attrClear _ = undefined + +formFieldMapping_area :: AttrLabelProxy "area" +formFieldMapping_area = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@field@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' formFieldMapping #field +@ +-} +getFormFieldMappingField :: MonadIO m => FormFieldMapping -> m (Maybe Poppler.FormField.FormField) +getFormFieldMappingField s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 32) :: IO (Ptr Poppler.FormField.FormField) + result <- SP.convertIfNonNull val $ \val' -> do + val'' <- (newObject Poppler.FormField.FormField) val' + return val'' + return result + +{- | +Set the value of the “@field@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' formFieldMapping [ #field 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setFormFieldMappingField :: MonadIO m => FormFieldMapping -> Ptr Poppler.FormField.FormField -> m () +setFormFieldMappingField s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 32) (val :: Ptr Poppler.FormField.FormField) + +{- | +Set the value of the “@field@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #field +@ +-} +clearFormFieldMappingField :: MonadIO m => FormFieldMapping -> m () +clearFormFieldMappingField s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 32) (FP.nullPtr :: Ptr Poppler.FormField.FormField) + +#if ENABLE_OVERLOADING +data FormFieldMappingFieldFieldInfo +instance AttrInfo FormFieldMappingFieldFieldInfo where + type AttrAllowedOps FormFieldMappingFieldFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint FormFieldMappingFieldFieldInfo = (~) (Ptr Poppler.FormField.FormField) + type AttrBaseTypeConstraint FormFieldMappingFieldFieldInfo = (~) FormFieldMapping + type AttrGetType FormFieldMappingFieldFieldInfo = Maybe Poppler.FormField.FormField + type AttrLabel FormFieldMappingFieldFieldInfo = "field" + type AttrOrigin FormFieldMappingFieldFieldInfo = FormFieldMapping + attrGet _ = getFormFieldMappingField + attrSet _ = setFormFieldMappingField + attrConstruct = undefined + attrClear _ = clearFormFieldMappingField + +formFieldMapping_field :: AttrLabelProxy "field" +formFieldMapping_field = AttrLabelProxy + +#endif + + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList FormFieldMapping +type instance O.AttributeList FormFieldMapping = FormFieldMappingAttributeList +type FormFieldMappingAttributeList = ('[ '("area", FormFieldMappingAreaFieldInfo), '("field", FormFieldMappingFieldFieldInfo)] :: [(Symbol, *)]) +#endif + +-- method FormFieldMapping::new +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "FormFieldMapping"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_form_field_mapping_new" poppler_form_field_mapping_new :: + IO (Ptr FormFieldMapping) + +{- | +Creates a new 'GI.Poppler.Structs.FormFieldMapping.FormFieldMapping' +-} +formFieldMappingNew :: + (B.CallStack.HasCallStack, MonadIO m) => + m FormFieldMapping + {- ^ __Returns:__ a new 'GI.Poppler.Structs.FormFieldMapping.FormFieldMapping', use 'GI.Poppler.Structs.FormFieldMapping.formFieldMappingFree' to free it -} +formFieldMappingNew = liftIO $ do + result <- poppler_form_field_mapping_new + checkUnexpectedReturnNULL "formFieldMappingNew" result + result' <- (wrapBoxed FormFieldMapping) result + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method FormFieldMapping::copy +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "mapping", argType = TInterface (Name {namespace = "Poppler", name = "FormFieldMapping"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerFormFieldMapping to copy", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "FormFieldMapping"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_form_field_mapping_copy" poppler_form_field_mapping_copy :: + Ptr FormFieldMapping -> -- mapping : TInterface (Name {namespace = "Poppler", name = "FormFieldMapping"}) + IO (Ptr FormFieldMapping) + +{- | +Creates a copy of /@mapping@/ +-} +formFieldMappingCopy :: + (B.CallStack.HasCallStack, MonadIO m) => + FormFieldMapping + {- ^ /@mapping@/: a 'GI.Poppler.Structs.FormFieldMapping.FormFieldMapping' to copy -} + -> m FormFieldMapping + {- ^ __Returns:__ a new allocated copy of /@mapping@/ -} +formFieldMappingCopy mapping = liftIO $ do + mapping' <- unsafeManagedPtrGetPtr mapping + result <- poppler_form_field_mapping_copy mapping' + checkUnexpectedReturnNULL "formFieldMappingCopy" result + result' <- (wrapBoxed FormFieldMapping) result + touchManagedPtr mapping + return result' + +#if ENABLE_OVERLOADING +data FormFieldMappingCopyMethodInfo +instance (signature ~ (m FormFieldMapping), MonadIO m) => O.MethodInfo FormFieldMappingCopyMethodInfo FormFieldMapping signature where + overloadedMethod _ = formFieldMappingCopy + +#endif + +-- method FormFieldMapping::free +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "mapping", argType = TInterface (Name {namespace = "Poppler", name = "FormFieldMapping"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerFormFieldMapping", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_form_field_mapping_free" poppler_form_field_mapping_free :: + Ptr FormFieldMapping -> -- mapping : TInterface (Name {namespace = "Poppler", name = "FormFieldMapping"}) + IO () + +{- | +Frees the given 'GI.Poppler.Structs.FormFieldMapping.FormFieldMapping' +-} +formFieldMappingFree :: + (B.CallStack.HasCallStack, MonadIO m) => + FormFieldMapping + {- ^ /@mapping@/: a 'GI.Poppler.Structs.FormFieldMapping.FormFieldMapping' -} + -> m () +formFieldMappingFree mapping = liftIO $ do + mapping' <- unsafeManagedPtrGetPtr mapping + poppler_form_field_mapping_free mapping' + touchManagedPtr mapping + return () + +#if ENABLE_OVERLOADING +data FormFieldMappingFreeMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo FormFieldMappingFreeMethodInfo FormFieldMapping signature where + overloadedMethod _ = formFieldMappingFree + +#endif + +#if ENABLE_OVERLOADING +type family ResolveFormFieldMappingMethod (t :: Symbol) (o :: *) :: * where + ResolveFormFieldMappingMethod "copy" o = FormFieldMappingCopyMethodInfo + ResolveFormFieldMappingMethod "free" o = FormFieldMappingFreeMethodInfo + ResolveFormFieldMappingMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveFormFieldMappingMethod t FormFieldMapping, O.MethodInfo info FormFieldMapping p) => OL.IsLabel t (FormFieldMapping -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + 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,32 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Poppler.Structs.FormFieldMapping where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype FormFieldMapping = FormFieldMapping (ManagedPtr FormFieldMapping) +instance BoxedObject FormFieldMapping where +#if ENABLE_OVERLOADING +data FormFieldMappingCopyMethodInfo +#endif +#if ENABLE_OVERLOADING +data FormFieldMappingFreeMethodInfo +#endif 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,314 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +A 'GI.Poppler.Structs.ImageMapping.ImageMapping' structure represents the location +of an image on the page +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Poppler.Structs.ImageMapping + ( + +-- * Exported types + ImageMapping(..) , + newZeroImageMapping , + noImageMapping , + + + -- * Methods +-- ** copy #method:copy# + +#if ENABLE_OVERLOADING + ImageMappingCopyMethodInfo , +#endif + imageMappingCopy , + + +-- ** free #method:free# + +#if ENABLE_OVERLOADING + ImageMappingFreeMethodInfo , +#endif + imageMappingFree , + + +-- ** new #method:new# + + imageMappingNew , + + + + + -- * Properties +-- ** area #attr:area# +{- | a 'GI.Poppler.Structs.Rectangle.Rectangle' representing an area of the page +-} + getImageMappingArea , +#if ENABLE_OVERLOADING + imageMapping_area , +#endif + + +-- ** imageId #attr:imageId# +{- | an image identifier +-} + getImageMappingImageId , +#if ENABLE_OVERLOADING + imageMapping_imageId , +#endif + setImageMappingImageId , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import {-# SOURCE #-} qualified GI.Poppler.Structs.Rectangle as Poppler.Rectangle + +-- | Memory-managed wrapper type. +newtype ImageMapping = ImageMapping (ManagedPtr 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 + +-- | Construct a `ImageMapping` struct initialized to zero. +newZeroImageMapping :: MonadIO m => m ImageMapping +newZeroImageMapping = liftIO $ callocBoxedBytes 40 >>= wrapBoxed ImageMapping + +instance tag ~ 'AttrSet => Constructible ImageMapping tag where + new _ attrs = do + o <- newZeroImageMapping + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `ImageMapping`. +noImageMapping :: Maybe ImageMapping +noImageMapping = Nothing + +{- | +Get the value of the “@area@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' imageMapping #area +@ +-} +getImageMappingArea :: MonadIO m => ImageMapping -> m Poppler.Rectangle.Rectangle +getImageMappingArea s = liftIO $ withManagedPtr s $ \ptr -> do + let val = ptr `plusPtr` 0 :: (Ptr Poppler.Rectangle.Rectangle) + val' <- (newBoxed Poppler.Rectangle.Rectangle) val + return val' + +#if ENABLE_OVERLOADING +data ImageMappingAreaFieldInfo +instance AttrInfo ImageMappingAreaFieldInfo where + type AttrAllowedOps ImageMappingAreaFieldInfo = '[ 'AttrGet] + type AttrSetTypeConstraint ImageMappingAreaFieldInfo = (~) (Ptr Poppler.Rectangle.Rectangle) + type AttrBaseTypeConstraint ImageMappingAreaFieldInfo = (~) ImageMapping + type AttrGetType ImageMappingAreaFieldInfo = Poppler.Rectangle.Rectangle + type AttrLabel ImageMappingAreaFieldInfo = "area" + type AttrOrigin ImageMappingAreaFieldInfo = ImageMapping + attrGet _ = getImageMappingArea + attrSet _ = undefined + attrConstruct = undefined + attrClear _ = undefined + +imageMapping_area :: AttrLabelProxy "area" +imageMapping_area = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@image_id@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' imageMapping #imageId +@ +-} +getImageMappingImageId :: MonadIO m => ImageMapping -> m Int32 +getImageMappingImageId s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 32) :: IO Int32 + return val + +{- | +Set the value of the “@image_id@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' imageMapping [ #imageId 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setImageMappingImageId :: MonadIO m => ImageMapping -> Int32 -> m () +setImageMappingImageId s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 32) (val :: Int32) + +#if ENABLE_OVERLOADING +data ImageMappingImageIdFieldInfo +instance AttrInfo ImageMappingImageIdFieldInfo where + type AttrAllowedOps ImageMappingImageIdFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint ImageMappingImageIdFieldInfo = (~) Int32 + type AttrBaseTypeConstraint ImageMappingImageIdFieldInfo = (~) ImageMapping + type AttrGetType ImageMappingImageIdFieldInfo = Int32 + type AttrLabel ImageMappingImageIdFieldInfo = "image_id" + type AttrOrigin ImageMappingImageIdFieldInfo = ImageMapping + attrGet _ = getImageMappingImageId + attrSet _ = setImageMappingImageId + attrConstruct = undefined + attrClear _ = undefined + +imageMapping_imageId :: AttrLabelProxy "imageId" +imageMapping_imageId = AttrLabelProxy + +#endif + + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList ImageMapping +type instance O.AttributeList ImageMapping = ImageMappingAttributeList +type ImageMappingAttributeList = ('[ '("area", ImageMappingAreaFieldInfo), '("imageId", ImageMappingImageIdFieldInfo)] :: [(Symbol, *)]) +#endif + +-- method ImageMapping::new +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "ImageMapping"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_image_mapping_new" poppler_image_mapping_new :: + IO (Ptr ImageMapping) + +{- | +Creates a new 'GI.Poppler.Structs.ImageMapping.ImageMapping' +-} +imageMappingNew :: + (B.CallStack.HasCallStack, MonadIO m) => + m ImageMapping + {- ^ __Returns:__ a new 'GI.Poppler.Structs.ImageMapping.ImageMapping', use 'GI.Poppler.Structs.ImageMapping.imageMappingFree' to free it -} +imageMappingNew = liftIO $ do + result <- poppler_image_mapping_new + checkUnexpectedReturnNULL "imageMappingNew" result + result' <- (wrapBoxed ImageMapping) result + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method ImageMapping::copy +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "mapping", argType = TInterface (Name {namespace = "Poppler", name = "ImageMapping"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerImageMapping to copy", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "ImageMapping"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_image_mapping_copy" poppler_image_mapping_copy :: + Ptr ImageMapping -> -- mapping : TInterface (Name {namespace = "Poppler", name = "ImageMapping"}) + IO (Ptr ImageMapping) + +{- | +Creates a copy of /@mapping@/ +-} +imageMappingCopy :: + (B.CallStack.HasCallStack, MonadIO m) => + ImageMapping + {- ^ /@mapping@/: a 'GI.Poppler.Structs.ImageMapping.ImageMapping' to copy -} + -> m ImageMapping + {- ^ __Returns:__ a new allocated copy of /@mapping@/ -} +imageMappingCopy mapping = liftIO $ do + mapping' <- unsafeManagedPtrGetPtr mapping + result <- poppler_image_mapping_copy mapping' + checkUnexpectedReturnNULL "imageMappingCopy" result + result' <- (wrapBoxed ImageMapping) result + touchManagedPtr mapping + return result' + +#if ENABLE_OVERLOADING +data ImageMappingCopyMethodInfo +instance (signature ~ (m ImageMapping), MonadIO m) => O.MethodInfo ImageMappingCopyMethodInfo ImageMapping signature where + overloadedMethod _ = imageMappingCopy + +#endif + +-- method ImageMapping::free +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "mapping", argType = TInterface (Name {namespace = "Poppler", name = "ImageMapping"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerImageMapping", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_image_mapping_free" poppler_image_mapping_free :: + Ptr ImageMapping -> -- mapping : TInterface (Name {namespace = "Poppler", name = "ImageMapping"}) + IO () + +{- | +Frees the given 'GI.Poppler.Structs.ImageMapping.ImageMapping' +-} +imageMappingFree :: + (B.CallStack.HasCallStack, MonadIO m) => + ImageMapping + {- ^ /@mapping@/: a 'GI.Poppler.Structs.ImageMapping.ImageMapping' -} + -> m () +imageMappingFree mapping = liftIO $ do + mapping' <- unsafeManagedPtrGetPtr mapping + poppler_image_mapping_free mapping' + touchManagedPtr mapping + return () + +#if ENABLE_OVERLOADING +data ImageMappingFreeMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo ImageMappingFreeMethodInfo ImageMapping signature where + overloadedMethod _ = imageMappingFree + +#endif + +#if ENABLE_OVERLOADING +type family ResolveImageMappingMethod (t :: Symbol) (o :: *) :: * where + ResolveImageMappingMethod "copy" o = ImageMappingCopyMethodInfo + ResolveImageMappingMethod "free" o = ImageMappingFreeMethodInfo + ResolveImageMappingMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveImageMappingMethod t ImageMapping, O.MethodInfo info ImageMapping p) => OL.IsLabel t (ImageMapping -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + 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,32 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Poppler.Structs.ImageMapping where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype ImageMapping = ImageMapping (ManagedPtr ImageMapping) +instance BoxedObject ImageMapping where +#if ENABLE_OVERLOADING +data ImageMappingCopyMethodInfo +#endif +#if ENABLE_OVERLOADING +data ImageMappingFreeMethodInfo +#endif 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,421 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Poppler.Structs.IndexIter + ( + +-- * Exported types + IndexIter(..) , + noIndexIter , + + + -- * Methods +-- ** copy #method:copy# + +#if ENABLE_OVERLOADING + IndexIterCopyMethodInfo , +#endif + indexIterCopy , + + +-- ** free #method:free# + +#if ENABLE_OVERLOADING + IndexIterFreeMethodInfo , +#endif + indexIterFree , + + +-- ** getAction #method:getAction# + +#if ENABLE_OVERLOADING + IndexIterGetActionMethodInfo , +#endif + indexIterGetAction , + + +-- ** getChild #method:getChild# + +#if ENABLE_OVERLOADING + IndexIterGetChildMethodInfo , +#endif + indexIterGetChild , + + +-- ** isOpen #method:isOpen# + +#if ENABLE_OVERLOADING + IndexIterIsOpenMethodInfo , +#endif + indexIterIsOpen , + + +-- ** new #method:new# + + indexIterNew , + + +-- ** next #method:next# + +#if ENABLE_OVERLOADING + IndexIterNextMethodInfo , +#endif + indexIterNext , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import {-# SOURCE #-} qualified GI.Poppler.Objects.Document as Poppler.Document +import {-# SOURCE #-} qualified GI.Poppler.Unions.Action as Poppler.Action + +-- | Memory-managed wrapper type. +newtype IndexIter = IndexIter (ManagedPtr 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 + +-- | A convenience alias for `Nothing` :: `Maybe` `IndexIter`. +noIndexIter :: Maybe IndexIter +noIndexIter = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList IndexIter +type instance O.AttributeList IndexIter = IndexIterAttributeList +type IndexIterAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method IndexIter::new +-- method type : Constructor +-- Args : [Arg {argCName = "document", argType = TInterface (Name {namespace = "Poppler", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "IndexIter"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_index_iter_new" poppler_index_iter_new :: + Ptr Poppler.Document.Document -> -- document : TInterface (Name {namespace = "Poppler", name = "Document"}) + IO (Ptr IndexIter) + +{- | +Returns the root 'GI.Poppler.Structs.IndexIter.IndexIter' for /@document@/, or 'Nothing'. This must be +freed with 'GI.Poppler.Structs.IndexIter.indexIterFree'. + +Certain documents have an index associated with them. This index can be used +to help the user navigate the document, and is similar to a table of +contents. Each node in the index will contain a 'GI.Poppler.Unions.Action.Action' that can be +displayed to the user — typically a @/POPPLER_ACTION_GOTO_DEST/@ or a +@/POPPLER_ACTION_URI/@\. + +Here is a simple example of some code that walks the full index: + +\\ +static void +walk_index (PopplerIndexIter *iter) +{ + do + { + \/\* Get the action and do something with it *\\/ + PopplerIndexIter *child = poppler_index_iter_get_child (iter); + if (child) + walk_index (child); + poppler_index_iter_free (child); + } + while (poppler_index_iter_next (iter)); +} +... +{ + iter = poppler_index_iter_new (document); + walk_index (iter); + poppler_index_iter_free (iter); +} +\<\/programlisting>\<\/informalexample> +-} +indexIterNew :: + (B.CallStack.HasCallStack, MonadIO m, Poppler.Document.IsDocument a) => + a + {- ^ /@document@/: a 'GI.Poppler.Objects.Document.Document' -} + -> m IndexIter + {- ^ __Returns:__ a new 'GI.Poppler.Structs.IndexIter.IndexIter' -} +indexIterNew document = liftIO $ do + document' <- unsafeManagedPtrCastPtr document + result <- poppler_index_iter_new document' + checkUnexpectedReturnNULL "indexIterNew" result + result' <- (wrapBoxed IndexIter) result + touchManagedPtr document + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method IndexIter::copy +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "iter", argType = TInterface (Name {namespace = "Poppler", name = "IndexIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerIndexIter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "IndexIter"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_index_iter_copy" poppler_index_iter_copy :: + Ptr IndexIter -> -- iter : TInterface (Name {namespace = "Poppler", name = "IndexIter"}) + IO (Ptr IndexIter) + +{- | +Creates a new 'GI.Poppler.Structs.IndexIter.IndexIter' as a copy of /@iter@/. This must be freed with +'GI.Poppler.Structs.IndexIter.indexIterFree'. +-} +indexIterCopy :: + (B.CallStack.HasCallStack, MonadIO m) => + IndexIter + {- ^ /@iter@/: a 'GI.Poppler.Structs.IndexIter.IndexIter' -} + -> m IndexIter + {- ^ __Returns:__ a new 'GI.Poppler.Structs.IndexIter.IndexIter' -} +indexIterCopy iter = liftIO $ do + iter' <- unsafeManagedPtrGetPtr iter + result <- poppler_index_iter_copy iter' + checkUnexpectedReturnNULL "indexIterCopy" result + result' <- (wrapBoxed IndexIter) result + touchManagedPtr iter + return result' + +#if ENABLE_OVERLOADING +data IndexIterCopyMethodInfo +instance (signature ~ (m IndexIter), MonadIO m) => O.MethodInfo IndexIterCopyMethodInfo IndexIter signature where + overloadedMethod _ = indexIterCopy + +#endif + +-- method IndexIter::free +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "iter", argType = TInterface (Name {namespace = "Poppler", name = "IndexIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerIndexIter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_index_iter_free" poppler_index_iter_free :: + Ptr IndexIter -> -- iter : TInterface (Name {namespace = "Poppler", name = "IndexIter"}) + IO () + +{- | +Frees /@iter@/. +-} +indexIterFree :: + (B.CallStack.HasCallStack, MonadIO m) => + IndexIter + {- ^ /@iter@/: a 'GI.Poppler.Structs.IndexIter.IndexIter' -} + -> m () +indexIterFree iter = liftIO $ do + iter' <- unsafeManagedPtrGetPtr iter + poppler_index_iter_free iter' + touchManagedPtr iter + return () + +#if ENABLE_OVERLOADING +data IndexIterFreeMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo IndexIterFreeMethodInfo IndexIter signature where + overloadedMethod _ = indexIterFree + +#endif + +-- method IndexIter::get_action +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "iter", argType = TInterface (Name {namespace = "Poppler", name = "IndexIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerIndexIter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "Action"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_index_iter_get_action" poppler_index_iter_get_action :: + Ptr IndexIter -> -- iter : TInterface (Name {namespace = "Poppler", name = "IndexIter"}) + IO (Ptr Poppler.Action.Action) + +{- | +Returns the 'GI.Poppler.Unions.Action.Action' associated with /@iter@/. It must be freed with +'GI.Poppler.Unions.Action.actionFree'. +-} +indexIterGetAction :: + (B.CallStack.HasCallStack, MonadIO m) => + IndexIter + {- ^ /@iter@/: a 'GI.Poppler.Structs.IndexIter.IndexIter' -} + -> m Poppler.Action.Action + {- ^ __Returns:__ a new 'GI.Poppler.Unions.Action.Action' -} +indexIterGetAction iter = liftIO $ do + iter' <- unsafeManagedPtrGetPtr iter + result <- poppler_index_iter_get_action iter' + checkUnexpectedReturnNULL "indexIterGetAction" result + result' <- (wrapBoxed Poppler.Action.Action) result + touchManagedPtr iter + return result' + +#if ENABLE_OVERLOADING +data IndexIterGetActionMethodInfo +instance (signature ~ (m Poppler.Action.Action), MonadIO m) => O.MethodInfo IndexIterGetActionMethodInfo IndexIter signature where + overloadedMethod _ = indexIterGetAction + +#endif + +-- method IndexIter::get_child +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "parent", argType = TInterface (Name {namespace = "Poppler", name = "IndexIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerIndexIter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "IndexIter"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_index_iter_get_child" poppler_index_iter_get_child :: + Ptr IndexIter -> -- parent : TInterface (Name {namespace = "Poppler", name = "IndexIter"}) + IO (Ptr IndexIter) + +{- | +Returns a newly created child of /@parent@/, or 'Nothing' if the iter has no child. +See 'GI.Poppler.Structs.IndexIter.indexIterNew' for more information on this function. +-} +indexIterGetChild :: + (B.CallStack.HasCallStack, MonadIO m) => + IndexIter + {- ^ /@parent@/: a 'GI.Poppler.Structs.IndexIter.IndexIter' -} + -> m IndexIter + {- ^ __Returns:__ a new 'GI.Poppler.Structs.IndexIter.IndexIter' -} +indexIterGetChild parent = liftIO $ do + parent' <- unsafeManagedPtrGetPtr parent + result <- poppler_index_iter_get_child parent' + checkUnexpectedReturnNULL "indexIterGetChild" result + result' <- (wrapBoxed IndexIter) result + touchManagedPtr parent + return result' + +#if ENABLE_OVERLOADING +data IndexIterGetChildMethodInfo +instance (signature ~ (m IndexIter), MonadIO m) => O.MethodInfo IndexIterGetChildMethodInfo IndexIter signature where + overloadedMethod _ = indexIterGetChild + +#endif + +-- method IndexIter::is_open +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "iter", argType = TInterface (Name {namespace = "Poppler", name = "IndexIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerIndexIter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_index_iter_is_open" poppler_index_iter_is_open :: + Ptr IndexIter -> -- iter : TInterface (Name {namespace = "Poppler", name = "IndexIter"}) + IO CInt + +{- | +Returns whether this node should be expanded by default to the user. The +document can provide a hint as to how the document\'s index should be expanded +initially. +-} +indexIterIsOpen :: + (B.CallStack.HasCallStack, MonadIO m) => + IndexIter + {- ^ /@iter@/: a 'GI.Poppler.Structs.IndexIter.IndexIter' -} + -> m Bool + {- ^ __Returns:__ 'True', if the document wants /@iter@/ to be expanded -} +indexIterIsOpen iter = liftIO $ do + iter' <- unsafeManagedPtrGetPtr iter + result <- poppler_index_iter_is_open iter' + let result' = (/= 0) result + touchManagedPtr iter + return result' + +#if ENABLE_OVERLOADING +data IndexIterIsOpenMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo IndexIterIsOpenMethodInfo IndexIter signature where + overloadedMethod _ = indexIterIsOpen + +#endif + +-- method IndexIter::next +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "iter", argType = TInterface (Name {namespace = "Poppler", name = "IndexIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerIndexIter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_index_iter_next" poppler_index_iter_next :: + Ptr IndexIter -> -- iter : TInterface (Name {namespace = "Poppler", name = "IndexIter"}) + IO CInt + +{- | +Sets /@iter@/ to point to the next action at the current level, if valid. See +'GI.Poppler.Structs.IndexIter.indexIterNew' for more information. +-} +indexIterNext :: + (B.CallStack.HasCallStack, MonadIO m) => + IndexIter + {- ^ /@iter@/: a 'GI.Poppler.Structs.IndexIter.IndexIter' -} + -> m Bool + {- ^ __Returns:__ 'True', if /@iter@/ was set to the next action -} +indexIterNext iter = liftIO $ do + iter' <- unsafeManagedPtrGetPtr iter + result <- poppler_index_iter_next iter' + let result' = (/= 0) result + touchManagedPtr iter + return result' + +#if ENABLE_OVERLOADING +data IndexIterNextMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo IndexIterNextMethodInfo IndexIter signature where + overloadedMethod _ = indexIterNext + +#endif + +#if ENABLE_OVERLOADING +type family ResolveIndexIterMethod (t :: Symbol) (o :: *) :: * where + ResolveIndexIterMethod "copy" o = IndexIterCopyMethodInfo + ResolveIndexIterMethod "free" o = IndexIterFreeMethodInfo + ResolveIndexIterMethod "isOpen" o = IndexIterIsOpenMethodInfo + ResolveIndexIterMethod "next" o = IndexIterNextMethodInfo + ResolveIndexIterMethod "getAction" o = IndexIterGetActionMethodInfo + ResolveIndexIterMethod "getChild" o = IndexIterGetChildMethodInfo + ResolveIndexIterMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveIndexIterMethod t IndexIter, O.MethodInfo info IndexIter p) => OL.IsLabel t (IndexIter -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + 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,44 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Poppler.Structs.IndexIter where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype IndexIter = IndexIter (ManagedPtr IndexIter) +instance BoxedObject IndexIter where +#if ENABLE_OVERLOADING +data IndexIterCopyMethodInfo +#endif +#if ENABLE_OVERLOADING +data IndexIterFreeMethodInfo +#endif +#if ENABLE_OVERLOADING +data IndexIterGetActionMethodInfo +#endif +#if ENABLE_OVERLOADING +data IndexIterGetChildMethodInfo +#endif +#if ENABLE_OVERLOADING +data IndexIterIsOpenMethodInfo +#endif +#if ENABLE_OVERLOADING +data IndexIterNextMethodInfo +#endif 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,405 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Poppler.Structs.LayersIter + ( + +-- * Exported types + LayersIter(..) , + noLayersIter , + + + -- * Methods +-- ** copy #method:copy# + +#if ENABLE_OVERLOADING + LayersIterCopyMethodInfo , +#endif + layersIterCopy , + + +-- ** free #method:free# + +#if ENABLE_OVERLOADING + LayersIterFreeMethodInfo , +#endif + layersIterFree , + + +-- ** getChild #method:getChild# + +#if ENABLE_OVERLOADING + LayersIterGetChildMethodInfo , +#endif + layersIterGetChild , + + +-- ** getLayer #method:getLayer# + +#if ENABLE_OVERLOADING + LayersIterGetLayerMethodInfo , +#endif + layersIterGetLayer , + + +-- ** getTitle #method:getTitle# + +#if ENABLE_OVERLOADING + LayersIterGetTitleMethodInfo , +#endif + layersIterGetTitle , + + +-- ** new #method:new# + + layersIterNew , + + +-- ** next #method:next# + +#if ENABLE_OVERLOADING + LayersIterNextMethodInfo , +#endif + layersIterNext , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import {-# SOURCE #-} qualified GI.Poppler.Objects.Document as Poppler.Document +import {-# SOURCE #-} qualified GI.Poppler.Objects.Layer as Poppler.Layer + +-- | Memory-managed wrapper type. +newtype LayersIter = LayersIter (ManagedPtr 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 + +-- | A convenience alias for `Nothing` :: `Maybe` `LayersIter`. +noLayersIter :: Maybe LayersIter +noLayersIter = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList LayersIter +type instance O.AttributeList LayersIter = LayersIterAttributeList +type LayersIterAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method LayersIter::new +-- method type : Constructor +-- Args : [Arg {argCName = "document", argType = TInterface (Name {namespace = "Poppler", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerDocument", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "LayersIter"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_layers_iter_new" poppler_layers_iter_new :: + Ptr Poppler.Document.Document -> -- document : TInterface (Name {namespace = "Poppler", name = "Document"}) + IO (Ptr LayersIter) + +{- | +/No description available in the introspection data./ + +/Since: 0.12/ +-} +layersIterNew :: + (B.CallStack.HasCallStack, MonadIO m, Poppler.Document.IsDocument a) => + a + {- ^ /@document@/: a 'GI.Poppler.Objects.Document.Document' -} + -> m LayersIter +layersIterNew document = liftIO $ do + document' <- unsafeManagedPtrCastPtr document + result <- poppler_layers_iter_new document' + checkUnexpectedReturnNULL "layersIterNew" result + result' <- (wrapBoxed LayersIter) result + touchManagedPtr document + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method LayersIter::copy +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "iter", argType = TInterface (Name {namespace = "Poppler", name = "LayersIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerLayersIter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "LayersIter"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_layers_iter_copy" poppler_layers_iter_copy :: + Ptr LayersIter -> -- iter : TInterface (Name {namespace = "Poppler", name = "LayersIter"}) + IO (Ptr LayersIter) + +{- | +Creates a new 'GI.Poppler.Structs.LayersIter.LayersIter' as a copy of /@iter@/. This must be freed with +'GI.Poppler.Structs.LayersIter.layersIterFree'. +-} +layersIterCopy :: + (B.CallStack.HasCallStack, MonadIO m) => + LayersIter + {- ^ /@iter@/: a 'GI.Poppler.Structs.LayersIter.LayersIter' -} + -> m LayersIter + {- ^ __Returns:__ a new 'GI.Poppler.Structs.LayersIter.LayersIter' + +Since 0.12 -} +layersIterCopy iter = liftIO $ do + iter' <- unsafeManagedPtrGetPtr iter + result <- poppler_layers_iter_copy iter' + checkUnexpectedReturnNULL "layersIterCopy" result + result' <- (wrapBoxed LayersIter) result + touchManagedPtr iter + return result' + +#if ENABLE_OVERLOADING +data LayersIterCopyMethodInfo +instance (signature ~ (m LayersIter), MonadIO m) => O.MethodInfo LayersIterCopyMethodInfo LayersIter signature where + overloadedMethod _ = layersIterCopy + +#endif + +-- method LayersIter::free +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "iter", argType = TInterface (Name {namespace = "Poppler", name = "LayersIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerLayersIter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_layers_iter_free" poppler_layers_iter_free :: + Ptr LayersIter -> -- iter : TInterface (Name {namespace = "Poppler", name = "LayersIter"}) + IO () + +{- | +Frees /@iter@/. + +/Since: 0.12/ +-} +layersIterFree :: + (B.CallStack.HasCallStack, MonadIO m) => + LayersIter + {- ^ /@iter@/: a 'GI.Poppler.Structs.LayersIter.LayersIter' -} + -> m () +layersIterFree iter = liftIO $ do + iter' <- unsafeManagedPtrGetPtr iter + poppler_layers_iter_free iter' + touchManagedPtr iter + return () + +#if ENABLE_OVERLOADING +data LayersIterFreeMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo LayersIterFreeMethodInfo LayersIter signature where + overloadedMethod _ = layersIterFree + +#endif + +-- method LayersIter::get_child +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "parent", argType = TInterface (Name {namespace = "Poppler", name = "LayersIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerLayersIter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "LayersIter"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_layers_iter_get_child" poppler_layers_iter_get_child :: + Ptr LayersIter -> -- parent : TInterface (Name {namespace = "Poppler", name = "LayersIter"}) + IO (Ptr LayersIter) + +{- | +Returns a newly created child of /@parent@/, or 'Nothing' if the iter has no child. +See 'GI.Poppler.Structs.LayersIter.layersIterNew' for more information on this function. + +/Since: 0.12/ +-} +layersIterGetChild :: + (B.CallStack.HasCallStack, MonadIO m) => + LayersIter + {- ^ /@parent@/: a 'GI.Poppler.Structs.LayersIter.LayersIter' -} + -> m LayersIter + {- ^ __Returns:__ a new 'GI.Poppler.Structs.LayersIter.LayersIter', or 'Nothing' -} +layersIterGetChild parent = liftIO $ do + parent' <- unsafeManagedPtrGetPtr parent + result <- poppler_layers_iter_get_child parent' + checkUnexpectedReturnNULL "layersIterGetChild" result + result' <- (wrapBoxed LayersIter) result + touchManagedPtr parent + return result' + +#if ENABLE_OVERLOADING +data LayersIterGetChildMethodInfo +instance (signature ~ (m LayersIter), MonadIO m) => O.MethodInfo LayersIterGetChildMethodInfo LayersIter signature where + overloadedMethod _ = layersIterGetChild + +#endif + +-- method LayersIter::get_layer +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "iter", argType = TInterface (Name {namespace = "Poppler", name = "LayersIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerLayersIter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "Layer"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_layers_iter_get_layer" poppler_layers_iter_get_layer :: + Ptr LayersIter -> -- iter : TInterface (Name {namespace = "Poppler", name = "LayersIter"}) + IO (Ptr Poppler.Layer.Layer) + +{- | +Returns the 'GI.Poppler.Objects.Layer.Layer' associated with /@iter@/. + +/Since: 0.12/ +-} +layersIterGetLayer :: + (B.CallStack.HasCallStack, MonadIO m) => + LayersIter + {- ^ /@iter@/: a 'GI.Poppler.Structs.LayersIter.LayersIter' -} + -> m Poppler.Layer.Layer + {- ^ __Returns:__ a new 'GI.Poppler.Objects.Layer.Layer', or 'Nothing' if +there isn\'t any layer associated with /@iter@/ -} +layersIterGetLayer iter = liftIO $ do + iter' <- unsafeManagedPtrGetPtr iter + result <- poppler_layers_iter_get_layer iter' + checkUnexpectedReturnNULL "layersIterGetLayer" result + result' <- (wrapObject Poppler.Layer.Layer) result + touchManagedPtr iter + return result' + +#if ENABLE_OVERLOADING +data LayersIterGetLayerMethodInfo +instance (signature ~ (m Poppler.Layer.Layer), MonadIO m) => O.MethodInfo LayersIterGetLayerMethodInfo LayersIter signature where + overloadedMethod _ = layersIterGetLayer + +#endif + +-- method LayersIter::get_title +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "iter", argType = TInterface (Name {namespace = "Poppler", name = "LayersIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerLayersIter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_layers_iter_get_title" poppler_layers_iter_get_title :: + Ptr LayersIter -> -- iter : TInterface (Name {namespace = "Poppler", name = "LayersIter"}) + IO CString + +{- | +Returns the title associated with /@iter@/. It must be freed with +'GI.GLib.Functions.free'. + +/Since: 0.12/ +-} +layersIterGetTitle :: + (B.CallStack.HasCallStack, MonadIO m) => + LayersIter + {- ^ /@iter@/: a 'GI.Poppler.Structs.LayersIter.LayersIter' -} + -> m T.Text + {- ^ __Returns:__ a new string containing the /@iter@/\'s title or 'Nothing' if /@iter@/ doesn\'t have a title. +The returned string should be freed with 'GI.GLib.Functions.free' when no longer needed. -} +layersIterGetTitle iter = liftIO $ do + iter' <- unsafeManagedPtrGetPtr iter + result <- poppler_layers_iter_get_title iter' + checkUnexpectedReturnNULL "layersIterGetTitle" result + result' <- cstringToText result + freeMem result + touchManagedPtr iter + return result' + +#if ENABLE_OVERLOADING +data LayersIterGetTitleMethodInfo +instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo LayersIterGetTitleMethodInfo LayersIter signature where + overloadedMethod _ = layersIterGetTitle + +#endif + +-- method LayersIter::next +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "iter", argType = TInterface (Name {namespace = "Poppler", name = "LayersIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerLayersIter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_layers_iter_next" poppler_layers_iter_next :: + Ptr LayersIter -> -- iter : TInterface (Name {namespace = "Poppler", name = "LayersIter"}) + IO CInt + +{- | +Sets /@iter@/ to point to the next action at the current level, if valid. See +'GI.Poppler.Structs.LayersIter.layersIterNew' for more information. + +/Since: 0.12/ +-} +layersIterNext :: + (B.CallStack.HasCallStack, MonadIO m) => + LayersIter + {- ^ /@iter@/: a 'GI.Poppler.Structs.LayersIter.LayersIter' -} + -> m Bool + {- ^ __Returns:__ 'True', if /@iter@/ was set to the next action -} +layersIterNext iter = liftIO $ do + iter' <- unsafeManagedPtrGetPtr iter + result <- poppler_layers_iter_next iter' + let result' = (/= 0) result + touchManagedPtr iter + return result' + +#if ENABLE_OVERLOADING +data LayersIterNextMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo LayersIterNextMethodInfo LayersIter signature where + overloadedMethod _ = layersIterNext + +#endif + +#if ENABLE_OVERLOADING +type family ResolveLayersIterMethod (t :: Symbol) (o :: *) :: * where + ResolveLayersIterMethod "copy" o = LayersIterCopyMethodInfo + ResolveLayersIterMethod "free" o = LayersIterFreeMethodInfo + ResolveLayersIterMethod "next" o = LayersIterNextMethodInfo + ResolveLayersIterMethod "getChild" o = LayersIterGetChildMethodInfo + ResolveLayersIterMethod "getLayer" o = LayersIterGetLayerMethodInfo + ResolveLayersIterMethod "getTitle" o = LayersIterGetTitleMethodInfo + ResolveLayersIterMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveLayersIterMethod t LayersIter, O.MethodInfo info LayersIter p) => OL.IsLabel t (LayersIter -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + 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,44 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Poppler.Structs.LayersIter where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype LayersIter = LayersIter (ManagedPtr LayersIter) +instance BoxedObject LayersIter where +#if ENABLE_OVERLOADING +data LayersIterCopyMethodInfo +#endif +#if ENABLE_OVERLOADING +data LayersIterFreeMethodInfo +#endif +#if ENABLE_OVERLOADING +data LayersIterGetChildMethodInfo +#endif +#if ENABLE_OVERLOADING +data LayersIterGetLayerMethodInfo +#endif +#if ENABLE_OVERLOADING +data LayersIterGetTitleMethodInfo +#endif +#if ENABLE_OVERLOADING +data LayersIterNextMethodInfo +#endif 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,331 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +A 'GI.Poppler.Structs.LinkMapping.LinkMapping' structure represents the location +of /@action@/ on the page +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Poppler.Structs.LinkMapping + ( + +-- * Exported types + LinkMapping(..) , + newZeroLinkMapping , + noLinkMapping , + + + -- * Methods +-- ** copy #method:copy# + +#if ENABLE_OVERLOADING + LinkMappingCopyMethodInfo , +#endif + linkMappingCopy , + + +-- ** free #method:free# + +#if ENABLE_OVERLOADING + LinkMappingFreeMethodInfo , +#endif + linkMappingFree , + + +-- ** new #method:new# + + linkMappingNew , + + + + + -- * Properties +-- ** action #attr:action# +{- | a 'GI.Poppler.Unions.Action.Action' +-} + clearLinkMappingAction , + getLinkMappingAction , +#if ENABLE_OVERLOADING + linkMapping_action , +#endif + setLinkMappingAction , + + +-- ** area #attr:area# +{- | a 'GI.Poppler.Structs.Rectangle.Rectangle' representing an area of the page +-} + getLinkMappingArea , +#if ENABLE_OVERLOADING + linkMapping_area , +#endif + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import {-# SOURCE #-} qualified GI.Poppler.Structs.Rectangle as Poppler.Rectangle +import {-# SOURCE #-} qualified GI.Poppler.Unions.Action as Poppler.Action + +-- | Memory-managed wrapper type. +newtype LinkMapping = LinkMapping (ManagedPtr 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 + +-- | Construct a `LinkMapping` struct initialized to zero. +newZeroLinkMapping :: MonadIO m => m LinkMapping +newZeroLinkMapping = liftIO $ callocBoxedBytes 40 >>= wrapBoxed LinkMapping + +instance tag ~ 'AttrSet => Constructible LinkMapping tag where + new _ attrs = do + o <- newZeroLinkMapping + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `LinkMapping`. +noLinkMapping :: Maybe LinkMapping +noLinkMapping = Nothing + +{- | +Get the value of the “@area@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' linkMapping #area +@ +-} +getLinkMappingArea :: MonadIO m => LinkMapping -> m Poppler.Rectangle.Rectangle +getLinkMappingArea s = liftIO $ withManagedPtr s $ \ptr -> do + let val = ptr `plusPtr` 0 :: (Ptr Poppler.Rectangle.Rectangle) + val' <- (newBoxed Poppler.Rectangle.Rectangle) val + return val' + +#if ENABLE_OVERLOADING +data LinkMappingAreaFieldInfo +instance AttrInfo LinkMappingAreaFieldInfo where + type AttrAllowedOps LinkMappingAreaFieldInfo = '[ 'AttrGet] + type AttrSetTypeConstraint LinkMappingAreaFieldInfo = (~) (Ptr Poppler.Rectangle.Rectangle) + type AttrBaseTypeConstraint LinkMappingAreaFieldInfo = (~) LinkMapping + type AttrGetType LinkMappingAreaFieldInfo = Poppler.Rectangle.Rectangle + type AttrLabel LinkMappingAreaFieldInfo = "area" + type AttrOrigin LinkMappingAreaFieldInfo = LinkMapping + attrGet _ = getLinkMappingArea + attrSet _ = undefined + attrConstruct = undefined + attrClear _ = undefined + +linkMapping_area :: AttrLabelProxy "area" +linkMapping_area = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@action@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' linkMapping #action +@ +-} +getLinkMappingAction :: MonadIO m => LinkMapping -> m (Maybe Poppler.Action.Action) +getLinkMappingAction s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 32) :: IO (Ptr Poppler.Action.Action) + result <- SP.convertIfNonNull val $ \val' -> do + val'' <- (newBoxed Poppler.Action.Action) val' + return val'' + return result + +{- | +Set the value of the “@action@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' linkMapping [ #action 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setLinkMappingAction :: MonadIO m => LinkMapping -> Ptr Poppler.Action.Action -> m () +setLinkMappingAction s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 32) (val :: Ptr Poppler.Action.Action) + +{- | +Set the value of the “@action@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #action +@ +-} +clearLinkMappingAction :: MonadIO m => LinkMapping -> m () +clearLinkMappingAction s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 32) (FP.nullPtr :: Ptr Poppler.Action.Action) + +#if ENABLE_OVERLOADING +data LinkMappingActionFieldInfo +instance AttrInfo LinkMappingActionFieldInfo where + type AttrAllowedOps LinkMappingActionFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint LinkMappingActionFieldInfo = (~) (Ptr Poppler.Action.Action) + type AttrBaseTypeConstraint LinkMappingActionFieldInfo = (~) LinkMapping + type AttrGetType LinkMappingActionFieldInfo = Maybe Poppler.Action.Action + type AttrLabel LinkMappingActionFieldInfo = "action" + type AttrOrigin LinkMappingActionFieldInfo = LinkMapping + attrGet _ = getLinkMappingAction + attrSet _ = setLinkMappingAction + attrConstruct = undefined + attrClear _ = clearLinkMappingAction + +linkMapping_action :: AttrLabelProxy "action" +linkMapping_action = AttrLabelProxy + +#endif + + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList LinkMapping +type instance O.AttributeList LinkMapping = LinkMappingAttributeList +type LinkMappingAttributeList = ('[ '("area", LinkMappingAreaFieldInfo), '("action", LinkMappingActionFieldInfo)] :: [(Symbol, *)]) +#endif + +-- method LinkMapping::new +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "LinkMapping"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_link_mapping_new" poppler_link_mapping_new :: + IO (Ptr LinkMapping) + +{- | +Creates a new 'GI.Poppler.Structs.LinkMapping.LinkMapping' +-} +linkMappingNew :: + (B.CallStack.HasCallStack, MonadIO m) => + m LinkMapping + {- ^ __Returns:__ a new 'GI.Poppler.Structs.LinkMapping.LinkMapping', use 'GI.Poppler.Structs.LinkMapping.linkMappingFree' to free it -} +linkMappingNew = liftIO $ do + result <- poppler_link_mapping_new + checkUnexpectedReturnNULL "linkMappingNew" result + result' <- (wrapBoxed LinkMapping) result + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method LinkMapping::copy +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "mapping", argType = TInterface (Name {namespace = "Poppler", name = "LinkMapping"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerLinkMapping to copy", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "LinkMapping"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_link_mapping_copy" poppler_link_mapping_copy :: + Ptr LinkMapping -> -- mapping : TInterface (Name {namespace = "Poppler", name = "LinkMapping"}) + IO (Ptr LinkMapping) + +{- | +Creates a copy of /@mapping@/ +-} +linkMappingCopy :: + (B.CallStack.HasCallStack, MonadIO m) => + LinkMapping + {- ^ /@mapping@/: a 'GI.Poppler.Structs.LinkMapping.LinkMapping' to copy -} + -> m LinkMapping + {- ^ __Returns:__ a new allocated copy of /@mapping@/ -} +linkMappingCopy mapping = liftIO $ do + mapping' <- unsafeManagedPtrGetPtr mapping + result <- poppler_link_mapping_copy mapping' + checkUnexpectedReturnNULL "linkMappingCopy" result + result' <- (wrapBoxed LinkMapping) result + touchManagedPtr mapping + return result' + +#if ENABLE_OVERLOADING +data LinkMappingCopyMethodInfo +instance (signature ~ (m LinkMapping), MonadIO m) => O.MethodInfo LinkMappingCopyMethodInfo LinkMapping signature where + overloadedMethod _ = linkMappingCopy + +#endif + +-- method LinkMapping::free +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "mapping", argType = TInterface (Name {namespace = "Poppler", name = "LinkMapping"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerLinkMapping", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_link_mapping_free" poppler_link_mapping_free :: + Ptr LinkMapping -> -- mapping : TInterface (Name {namespace = "Poppler", name = "LinkMapping"}) + IO () + +{- | +Frees the given 'GI.Poppler.Structs.LinkMapping.LinkMapping' +-} +linkMappingFree :: + (B.CallStack.HasCallStack, MonadIO m) => + LinkMapping + {- ^ /@mapping@/: a 'GI.Poppler.Structs.LinkMapping.LinkMapping' -} + -> m () +linkMappingFree mapping = liftIO $ do + mapping' <- unsafeManagedPtrGetPtr mapping + poppler_link_mapping_free mapping' + touchManagedPtr mapping + return () + +#if ENABLE_OVERLOADING +data LinkMappingFreeMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo LinkMappingFreeMethodInfo LinkMapping signature where + overloadedMethod _ = linkMappingFree + +#endif + +#if ENABLE_OVERLOADING +type family ResolveLinkMappingMethod (t :: Symbol) (o :: *) :: * where + ResolveLinkMappingMethod "copy" o = LinkMappingCopyMethodInfo + ResolveLinkMappingMethod "free" o = LinkMappingFreeMethodInfo + ResolveLinkMappingMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveLinkMappingMethod t LinkMapping, O.MethodInfo info LinkMapping p) => OL.IsLabel t (LinkMapping -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + 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,32 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Poppler.Structs.LinkMapping where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype LinkMapping = LinkMapping (ManagedPtr LinkMapping) +instance BoxedObject LinkMapping where +#if ENABLE_OVERLOADING +data LinkMappingCopyMethodInfo +#endif +#if ENABLE_OVERLOADING +data LinkMappingFreeMethodInfo +#endif 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,677 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +A 'GI.Poppler.Structs.PageTransition.PageTransition' structures describes a visual transition +to use when moving between pages during a presentation +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Poppler.Structs.PageTransition + ( + +-- * Exported types + PageTransition(..) , + newZeroPageTransition , + noPageTransition , + + + -- * Methods +-- ** copy #method:copy# + +#if ENABLE_OVERLOADING + PageTransitionCopyMethodInfo , +#endif + pageTransitionCopy , + + +-- ** free #method:free# + +#if ENABLE_OVERLOADING + PageTransitionFreeMethodInfo , +#endif + pageTransitionFree , + + +-- ** new #method:new# + + pageTransitionNew , + + + + + -- * Properties +-- ** alignment #attr:alignment# +{- | the dimension in which the transition effect shall occur. +Only for @/POPPLER_PAGE_TRANSITION_SPLIT/@ and @/POPPLER_PAGE_TRANSITION_BLINDS/@ transition types +-} + getPageTransitionAlignment , +#if ENABLE_OVERLOADING + pageTransition_alignment , +#endif + setPageTransitionAlignment , + + +-- ** angle #attr:angle# +{- | the direction in which the specified transition effect shall moves, +expressed in degrees counterclockwise starting from a left-to-right direction. +Only for @/POPPLER_PAGE_TRANSITION_WIPE/@, @/POPPLER_PAGE_TRANSITION_GLITTER/@, @/POPPLER_PAGE_TRANSITION_FLY/@, +@/POPPLER_PAGE_TRANSITION_COVER/@, @/POPPLER_PAGE_TRANSITION_UNCOVER/@ and @/POPPLER_PAGE_TRANSITION_PUSH/@ +transition types +-} + getPageTransitionAngle , +#if ENABLE_OVERLOADING + pageTransition_angle , +#endif + setPageTransitionAngle , + + +-- ** direction #attr:direction# +{- | the direction of motion for the transition effect. +Only for @/POPPLER_PAGE_TRANSITION_SPLIT/@, @/POPPLER_PAGE_TRANSITION_BOX/@ and @/POPPLER_PAGE_TRANSITION_FLY/@ +transition types +-} + getPageTransitionDirection , +#if ENABLE_OVERLOADING + pageTransition_direction , +#endif + setPageTransitionDirection , + + +-- ** duration #attr:duration# +{- | the duration of the transition effect +-} + getPageTransitionDuration , +#if ENABLE_OVERLOADING + pageTransition_duration , +#endif + setPageTransitionDuration , + + +-- ** durationReal #attr:durationReal# +{- | /No description available in the introspection data./ +-} + getPageTransitionDurationReal , +#if ENABLE_OVERLOADING + pageTransition_durationReal , +#endif + setPageTransitionDurationReal , + + +-- ** rectangular #attr:rectangular# +{- | whether the area that will be flown is rectangular and opaque. +Only for @/POPPLER_PAGE_TRANSITION_FLY/@ transition type +-} + getPageTransitionRectangular , +#if ENABLE_OVERLOADING + pageTransition_rectangular , +#endif + setPageTransitionRectangular , + + +-- ** scale #attr:scale# +{- | the starting or ending scale at which the changes shall be drawn. +Only for @/POPPLER_PAGE_TRANSITION_FLY/@ transition type +-} + getPageTransitionScale , +#if ENABLE_OVERLOADING + pageTransition_scale , +#endif + setPageTransitionScale , + + +-- ** type #attr:type# +{- | the type of transtition +-} + getPageTransitionType , +#if ENABLE_OVERLOADING + pageTransition_type , +#endif + setPageTransitionType , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import {-# SOURCE #-} qualified GI.Poppler.Enums as Poppler.Enums + +-- | Memory-managed wrapper type. +newtype PageTransition = PageTransition (ManagedPtr 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 + +-- | Construct a `PageTransition` struct initialized to zero. +newZeroPageTransition :: MonadIO m => m PageTransition +newZeroPageTransition = liftIO $ callocBoxedBytes 48 >>= wrapBoxed PageTransition + +instance tag ~ 'AttrSet => Constructible PageTransition tag where + new _ attrs = do + o <- newZeroPageTransition + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `PageTransition`. +noPageTransition :: Maybe PageTransition +noPageTransition = Nothing + +{- | +Get the value of the “@type@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' pageTransition #type +@ +-} +getPageTransitionType :: MonadIO m => PageTransition -> m Poppler.Enums.PageTransitionType +getPageTransitionType s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO CUInt + let val' = (toEnum . fromIntegral) val + return val' + +{- | +Set the value of the “@type@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' pageTransition [ #type 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setPageTransitionType :: MonadIO m => PageTransition -> Poppler.Enums.PageTransitionType -> m () +setPageTransitionType s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = (fromIntegral . fromEnum) val + poke (ptr `plusPtr` 0) (val' :: CUInt) + +#if ENABLE_OVERLOADING +data PageTransitionTypeFieldInfo +instance AttrInfo PageTransitionTypeFieldInfo where + type AttrAllowedOps PageTransitionTypeFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint PageTransitionTypeFieldInfo = (~) Poppler.Enums.PageTransitionType + type AttrBaseTypeConstraint PageTransitionTypeFieldInfo = (~) PageTransition + type AttrGetType PageTransitionTypeFieldInfo = Poppler.Enums.PageTransitionType + type AttrLabel PageTransitionTypeFieldInfo = "type" + type AttrOrigin PageTransitionTypeFieldInfo = PageTransition + attrGet _ = getPageTransitionType + attrSet _ = setPageTransitionType + attrConstruct = undefined + attrClear _ = undefined + +pageTransition_type :: AttrLabelProxy "type" +pageTransition_type = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@alignment@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' pageTransition #alignment +@ +-} +getPageTransitionAlignment :: MonadIO m => PageTransition -> m Poppler.Enums.PageTransitionAlignment +getPageTransitionAlignment s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 4) :: IO CUInt + let val' = (toEnum . fromIntegral) val + return val' + +{- | +Set the value of the “@alignment@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' pageTransition [ #alignment 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setPageTransitionAlignment :: MonadIO m => PageTransition -> Poppler.Enums.PageTransitionAlignment -> m () +setPageTransitionAlignment s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = (fromIntegral . fromEnum) val + poke (ptr `plusPtr` 4) (val' :: CUInt) + +#if ENABLE_OVERLOADING +data PageTransitionAlignmentFieldInfo +instance AttrInfo PageTransitionAlignmentFieldInfo where + type AttrAllowedOps PageTransitionAlignmentFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint PageTransitionAlignmentFieldInfo = (~) Poppler.Enums.PageTransitionAlignment + type AttrBaseTypeConstraint PageTransitionAlignmentFieldInfo = (~) PageTransition + type AttrGetType PageTransitionAlignmentFieldInfo = Poppler.Enums.PageTransitionAlignment + type AttrLabel PageTransitionAlignmentFieldInfo = "alignment" + type AttrOrigin PageTransitionAlignmentFieldInfo = PageTransition + attrGet _ = getPageTransitionAlignment + attrSet _ = setPageTransitionAlignment + attrConstruct = undefined + attrClear _ = undefined + +pageTransition_alignment :: AttrLabelProxy "alignment" +pageTransition_alignment = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@direction@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' pageTransition #direction +@ +-} +getPageTransitionDirection :: MonadIO m => PageTransition -> m Poppler.Enums.PageTransitionDirection +getPageTransitionDirection s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 8) :: IO CUInt + let val' = (toEnum . fromIntegral) val + return val' + +{- | +Set the value of the “@direction@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' pageTransition [ #direction 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setPageTransitionDirection :: MonadIO m => PageTransition -> Poppler.Enums.PageTransitionDirection -> m () +setPageTransitionDirection s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = (fromIntegral . fromEnum) val + poke (ptr `plusPtr` 8) (val' :: CUInt) + +#if ENABLE_OVERLOADING +data PageTransitionDirectionFieldInfo +instance AttrInfo PageTransitionDirectionFieldInfo where + type AttrAllowedOps PageTransitionDirectionFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint PageTransitionDirectionFieldInfo = (~) Poppler.Enums.PageTransitionDirection + type AttrBaseTypeConstraint PageTransitionDirectionFieldInfo = (~) PageTransition + type AttrGetType PageTransitionDirectionFieldInfo = Poppler.Enums.PageTransitionDirection + type AttrLabel PageTransitionDirectionFieldInfo = "direction" + type AttrOrigin PageTransitionDirectionFieldInfo = PageTransition + attrGet _ = getPageTransitionDirection + attrSet _ = setPageTransitionDirection + attrConstruct = undefined + attrClear _ = undefined + +pageTransition_direction :: AttrLabelProxy "direction" +pageTransition_direction = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@duration@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' pageTransition #duration +@ +-} +getPageTransitionDuration :: MonadIO m => PageTransition -> m Int32 +getPageTransitionDuration s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 12) :: IO Int32 + return val + +{- | +Set the value of the “@duration@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' pageTransition [ #duration 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setPageTransitionDuration :: MonadIO m => PageTransition -> Int32 -> m () +setPageTransitionDuration s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 12) (val :: Int32) + +#if ENABLE_OVERLOADING +data PageTransitionDurationFieldInfo +instance AttrInfo PageTransitionDurationFieldInfo where + type AttrAllowedOps PageTransitionDurationFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint PageTransitionDurationFieldInfo = (~) Int32 + type AttrBaseTypeConstraint PageTransitionDurationFieldInfo = (~) PageTransition + type AttrGetType PageTransitionDurationFieldInfo = Int32 + type AttrLabel PageTransitionDurationFieldInfo = "duration" + type AttrOrigin PageTransitionDurationFieldInfo = PageTransition + attrGet _ = getPageTransitionDuration + attrSet _ = setPageTransitionDuration + attrConstruct = undefined + attrClear _ = undefined + +pageTransition_duration :: AttrLabelProxy "duration" +pageTransition_duration = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@angle@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' pageTransition #angle +@ +-} +getPageTransitionAngle :: MonadIO m => PageTransition -> m Int32 +getPageTransitionAngle s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 16) :: IO Int32 + return val + +{- | +Set the value of the “@angle@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' pageTransition [ #angle 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setPageTransitionAngle :: MonadIO m => PageTransition -> Int32 -> m () +setPageTransitionAngle s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 16) (val :: Int32) + +#if ENABLE_OVERLOADING +data PageTransitionAngleFieldInfo +instance AttrInfo PageTransitionAngleFieldInfo where + type AttrAllowedOps PageTransitionAngleFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint PageTransitionAngleFieldInfo = (~) Int32 + type AttrBaseTypeConstraint PageTransitionAngleFieldInfo = (~) PageTransition + type AttrGetType PageTransitionAngleFieldInfo = Int32 + type AttrLabel PageTransitionAngleFieldInfo = "angle" + type AttrOrigin PageTransitionAngleFieldInfo = PageTransition + attrGet _ = getPageTransitionAngle + attrSet _ = setPageTransitionAngle + attrConstruct = undefined + attrClear _ = undefined + +pageTransition_angle :: AttrLabelProxy "angle" +pageTransition_angle = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@scale@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' pageTransition #scale +@ +-} +getPageTransitionScale :: MonadIO m => PageTransition -> m Double +getPageTransitionScale s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 24) :: IO CDouble + let val' = realToFrac val + return val' + +{- | +Set the value of the “@scale@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' pageTransition [ #scale 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setPageTransitionScale :: MonadIO m => PageTransition -> Double -> m () +setPageTransitionScale s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = realToFrac val + poke (ptr `plusPtr` 24) (val' :: CDouble) + +#if ENABLE_OVERLOADING +data PageTransitionScaleFieldInfo +instance AttrInfo PageTransitionScaleFieldInfo where + type AttrAllowedOps PageTransitionScaleFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint PageTransitionScaleFieldInfo = (~) Double + type AttrBaseTypeConstraint PageTransitionScaleFieldInfo = (~) PageTransition + type AttrGetType PageTransitionScaleFieldInfo = Double + type AttrLabel PageTransitionScaleFieldInfo = "scale" + type AttrOrigin PageTransitionScaleFieldInfo = PageTransition + attrGet _ = getPageTransitionScale + attrSet _ = setPageTransitionScale + attrConstruct = undefined + attrClear _ = undefined + +pageTransition_scale :: AttrLabelProxy "scale" +pageTransition_scale = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@rectangular@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' pageTransition #rectangular +@ +-} +getPageTransitionRectangular :: MonadIO m => PageTransition -> m Bool +getPageTransitionRectangular s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 32) :: IO CInt + let val' = (/= 0) val + return val' + +{- | +Set the value of the “@rectangular@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' pageTransition [ #rectangular 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setPageTransitionRectangular :: MonadIO m => PageTransition -> Bool -> m () +setPageTransitionRectangular s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = (fromIntegral . fromEnum) val + poke (ptr `plusPtr` 32) (val' :: CInt) + +#if ENABLE_OVERLOADING +data PageTransitionRectangularFieldInfo +instance AttrInfo PageTransitionRectangularFieldInfo where + type AttrAllowedOps PageTransitionRectangularFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint PageTransitionRectangularFieldInfo = (~) Bool + type AttrBaseTypeConstraint PageTransitionRectangularFieldInfo = (~) PageTransition + type AttrGetType PageTransitionRectangularFieldInfo = Bool + type AttrLabel PageTransitionRectangularFieldInfo = "rectangular" + type AttrOrigin PageTransitionRectangularFieldInfo = PageTransition + attrGet _ = getPageTransitionRectangular + attrSet _ = setPageTransitionRectangular + attrConstruct = undefined + attrClear _ = undefined + +pageTransition_rectangular :: AttrLabelProxy "rectangular" +pageTransition_rectangular = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@duration_real@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' pageTransition #durationReal +@ +-} +getPageTransitionDurationReal :: MonadIO m => PageTransition -> m Double +getPageTransitionDurationReal s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 40) :: IO CDouble + let val' = realToFrac val + return val' + +{- | +Set the value of the “@duration_real@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' pageTransition [ #durationReal 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setPageTransitionDurationReal :: MonadIO m => PageTransition -> Double -> m () +setPageTransitionDurationReal s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = realToFrac val + poke (ptr `plusPtr` 40) (val' :: CDouble) + +#if ENABLE_OVERLOADING +data PageTransitionDurationRealFieldInfo +instance AttrInfo PageTransitionDurationRealFieldInfo where + type AttrAllowedOps PageTransitionDurationRealFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint PageTransitionDurationRealFieldInfo = (~) Double + type AttrBaseTypeConstraint PageTransitionDurationRealFieldInfo = (~) PageTransition + type AttrGetType PageTransitionDurationRealFieldInfo = Double + type AttrLabel PageTransitionDurationRealFieldInfo = "duration_real" + type AttrOrigin PageTransitionDurationRealFieldInfo = PageTransition + attrGet _ = getPageTransitionDurationReal + attrSet _ = setPageTransitionDurationReal + attrConstruct = undefined + attrClear _ = undefined + +pageTransition_durationReal :: AttrLabelProxy "durationReal" +pageTransition_durationReal = AttrLabelProxy + +#endif + + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList PageTransition +type instance O.AttributeList PageTransition = PageTransitionAttributeList +type PageTransitionAttributeList = ('[ '("type", PageTransitionTypeFieldInfo), '("alignment", PageTransitionAlignmentFieldInfo), '("direction", PageTransitionDirectionFieldInfo), '("duration", PageTransitionDurationFieldInfo), '("angle", PageTransitionAngleFieldInfo), '("scale", PageTransitionScaleFieldInfo), '("rectangular", PageTransitionRectangularFieldInfo), '("durationReal", PageTransitionDurationRealFieldInfo)] :: [(Symbol, *)]) +#endif + +-- method PageTransition::new +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "PageTransition"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_page_transition_new" poppler_page_transition_new :: + IO (Ptr PageTransition) + +{- | +Creates a new 'GI.Poppler.Structs.PageTransition.PageTransition' +-} +pageTransitionNew :: + (B.CallStack.HasCallStack, MonadIO m) => + m PageTransition + {- ^ __Returns:__ a new 'GI.Poppler.Structs.PageTransition.PageTransition', use 'GI.Poppler.Structs.PageTransition.pageTransitionFree' to free it -} +pageTransitionNew = liftIO $ do + result <- poppler_page_transition_new + checkUnexpectedReturnNULL "pageTransitionNew" result + result' <- (wrapBoxed PageTransition) result + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method PageTransition::copy +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "transition", argType = TInterface (Name {namespace = "Poppler", name = "PageTransition"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerPageTransition to copy", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "PageTransition"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_page_transition_copy" poppler_page_transition_copy :: + Ptr PageTransition -> -- transition : TInterface (Name {namespace = "Poppler", name = "PageTransition"}) + IO (Ptr PageTransition) + +{- | +Creates a copy of /@transition@/ +-} +pageTransitionCopy :: + (B.CallStack.HasCallStack, MonadIO m) => + PageTransition + {- ^ /@transition@/: a 'GI.Poppler.Structs.PageTransition.PageTransition' to copy -} + -> m PageTransition + {- ^ __Returns:__ a new allocated copy of /@transition@/ -} +pageTransitionCopy transition = liftIO $ do + transition' <- unsafeManagedPtrGetPtr transition + result <- poppler_page_transition_copy transition' + checkUnexpectedReturnNULL "pageTransitionCopy" result + result' <- (wrapBoxed PageTransition) result + touchManagedPtr transition + return result' + +#if ENABLE_OVERLOADING +data PageTransitionCopyMethodInfo +instance (signature ~ (m PageTransition), MonadIO m) => O.MethodInfo PageTransitionCopyMethodInfo PageTransition signature where + overloadedMethod _ = pageTransitionCopy + +#endif + +-- method PageTransition::free +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "transition", argType = TInterface (Name {namespace = "Poppler", name = "PageTransition"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerPageTransition", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_page_transition_free" poppler_page_transition_free :: + Ptr PageTransition -> -- transition : TInterface (Name {namespace = "Poppler", name = "PageTransition"}) + IO () + +{- | +Frees the given 'GI.Poppler.Structs.PageTransition.PageTransition' +-} +pageTransitionFree :: + (B.CallStack.HasCallStack, MonadIO m) => + PageTransition + {- ^ /@transition@/: a 'GI.Poppler.Structs.PageTransition.PageTransition' -} + -> m () +pageTransitionFree transition = liftIO $ do + transition' <- unsafeManagedPtrGetPtr transition + poppler_page_transition_free transition' + touchManagedPtr transition + return () + +#if ENABLE_OVERLOADING +data PageTransitionFreeMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo PageTransitionFreeMethodInfo PageTransition signature where + overloadedMethod _ = pageTransitionFree + +#endif + +#if ENABLE_OVERLOADING +type family ResolvePageTransitionMethod (t :: Symbol) (o :: *) :: * where + ResolvePageTransitionMethod "copy" o = PageTransitionCopyMethodInfo + ResolvePageTransitionMethod "free" o = PageTransitionFreeMethodInfo + ResolvePageTransitionMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolvePageTransitionMethod t PageTransition, O.MethodInfo info PageTransition p) => OL.IsLabel t (PageTransition -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + 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,32 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Poppler.Structs.PageTransition where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype PageTransition = PageTransition (ManagedPtr PageTransition) +instance BoxedObject PageTransition where +#if ENABLE_OVERLOADING +data PageTransitionCopyMethodInfo +#endif +#if ENABLE_OVERLOADING +data PageTransitionFreeMethodInfo +#endif 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,335 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +A 'GI.Poppler.Structs.Point.Point' is used to describe a location point on a page +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Poppler.Structs.Point + ( + +-- * Exported types + Point(..) , + newZeroPoint , + noPoint , + + + -- * Methods +-- ** copy #method:copy# + +#if ENABLE_OVERLOADING + PointCopyMethodInfo , +#endif + pointCopy , + + +-- ** free #method:free# + +#if ENABLE_OVERLOADING + PointFreeMethodInfo , +#endif + pointFree , + + +-- ** new #method:new# + + pointNew , + + + + + -- * Properties +-- ** x #attr:x# +{- | x coordinate +-} + getPointX , +#if ENABLE_OVERLOADING + point_x , +#endif + setPointX , + + +-- ** y #attr:y# +{- | y coordinate +-} + getPointY , +#if ENABLE_OVERLOADING + point_y , +#endif + setPointY , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + + +-- | Memory-managed wrapper type. +newtype Point = Point (ManagedPtr 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 + +-- | Construct a `Point` struct initialized to zero. +newZeroPoint :: MonadIO m => m Point +newZeroPoint = liftIO $ callocBoxedBytes 16 >>= wrapBoxed Point + +instance tag ~ 'AttrSet => Constructible Point tag where + new _ attrs = do + o <- newZeroPoint + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `Point`. +noPoint :: Maybe Point +noPoint = Nothing + +{- | +Get the value of the “@x@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' point #x +@ +-} +getPointX :: MonadIO m => Point -> m Double +getPointX s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO CDouble + let val' = realToFrac val + return val' + +{- | +Set the value of the “@x@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' point [ #x 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setPointX :: MonadIO m => Point -> Double -> m () +setPointX s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = realToFrac val + poke (ptr `plusPtr` 0) (val' :: CDouble) + +#if ENABLE_OVERLOADING +data PointXFieldInfo +instance AttrInfo PointXFieldInfo where + type AttrAllowedOps PointXFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint PointXFieldInfo = (~) Double + type AttrBaseTypeConstraint PointXFieldInfo = (~) Point + type AttrGetType PointXFieldInfo = Double + type AttrLabel PointXFieldInfo = "x" + type AttrOrigin PointXFieldInfo = Point + attrGet _ = getPointX + attrSet _ = setPointX + attrConstruct = undefined + attrClear _ = undefined + +point_x :: AttrLabelProxy "x" +point_x = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@y@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' point #y +@ +-} +getPointY :: MonadIO m => Point -> m Double +getPointY s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 8) :: IO CDouble + let val' = realToFrac val + return val' + +{- | +Set the value of the “@y@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' point [ #y 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setPointY :: MonadIO m => Point -> Double -> m () +setPointY s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = realToFrac val + poke (ptr `plusPtr` 8) (val' :: CDouble) + +#if ENABLE_OVERLOADING +data PointYFieldInfo +instance AttrInfo PointYFieldInfo where + type AttrAllowedOps PointYFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint PointYFieldInfo = (~) Double + type AttrBaseTypeConstraint PointYFieldInfo = (~) Point + type AttrGetType PointYFieldInfo = Double + type AttrLabel PointYFieldInfo = "y" + type AttrOrigin PointYFieldInfo = Point + attrGet _ = getPointY + attrSet _ = setPointY + attrConstruct = undefined + attrClear _ = undefined + +point_y :: AttrLabelProxy "y" +point_y = AttrLabelProxy + +#endif + + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList Point +type instance O.AttributeList Point = PointAttributeList +type PointAttributeList = ('[ '("x", PointXFieldInfo), '("y", PointYFieldInfo)] :: [(Symbol, *)]) +#endif + +-- method Point::new +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "Point"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_point_new" poppler_point_new :: + IO (Ptr Point) + +{- | +Creates a new 'GI.Poppler.Structs.Point.Point'. It must be freed with 'GI.Poppler.Structs.Point.pointFree' after use. + +/Since: 0.26/ +-} +pointNew :: + (B.CallStack.HasCallStack, MonadIO m) => + m Point + {- ^ __Returns:__ a new 'GI.Poppler.Structs.Point.Point' -} +pointNew = liftIO $ do + result <- poppler_point_new + checkUnexpectedReturnNULL "pointNew" result + result' <- (wrapBoxed Point) result + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method Point::copy +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "point", argType = TInterface (Name {namespace = "Poppler", name = "Point"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerPoint to copy", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "Point"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_point_copy" poppler_point_copy :: + Ptr Point -> -- point : TInterface (Name {namespace = "Poppler", name = "Point"}) + IO (Ptr Point) + +{- | +Creates a copy of /@point@/. The copy must be freed with 'GI.Poppler.Structs.Point.pointFree' +after use. + +/Since: 0.26/ +-} +pointCopy :: + (B.CallStack.HasCallStack, MonadIO m) => + Point + {- ^ /@point@/: a 'GI.Poppler.Structs.Point.Point' to copy -} + -> m Point + {- ^ __Returns:__ a new allocated copy of /@point@/ -} +pointCopy point = liftIO $ do + point' <- unsafeManagedPtrGetPtr point + result <- poppler_point_copy point' + checkUnexpectedReturnNULL "pointCopy" result + result' <- (wrapBoxed Point) result + touchManagedPtr point + return result' + +#if ENABLE_OVERLOADING +data PointCopyMethodInfo +instance (signature ~ (m Point), MonadIO m) => O.MethodInfo PointCopyMethodInfo Point signature where + overloadedMethod _ = pointCopy + +#endif + +-- method Point::free +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "point", argType = TInterface (Name {namespace = "Poppler", name = "Point"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerPoint", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_point_free" poppler_point_free :: + Ptr Point -> -- point : TInterface (Name {namespace = "Poppler", name = "Point"}) + IO () + +{- | +Frees the memory used by /@point@/ + +/Since: 0.26/ +-} +pointFree :: + (B.CallStack.HasCallStack, MonadIO m) => + Point + {- ^ /@point@/: a 'GI.Poppler.Structs.Point.Point' -} + -> m () +pointFree point = liftIO $ do + point' <- unsafeManagedPtrGetPtr point + poppler_point_free point' + touchManagedPtr point + return () + +#if ENABLE_OVERLOADING +data PointFreeMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo PointFreeMethodInfo Point signature where + overloadedMethod _ = pointFree + +#endif + +#if ENABLE_OVERLOADING +type family ResolvePointMethod (t :: Symbol) (o :: *) :: * where + ResolvePointMethod "copy" o = PointCopyMethodInfo + ResolvePointMethod "free" o = PointFreeMethodInfo + ResolvePointMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolvePointMethod t Point, O.MethodInfo info Point p) => OL.IsLabel t (Point -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + 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,32 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Poppler.Structs.Point where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype Point = Point (ManagedPtr Point) +instance BoxedObject Point where +#if ENABLE_OVERLOADING +data PointCopyMethodInfo +#endif +#if ENABLE_OVERLOADING +data PointFreeMethodInfo +#endif 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,396 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +A 'GI.Poppler.Structs.Quadrilateral.Quadrilateral' is used to describe rectangle-like polygon + with arbitrary inclination on a page. + + Since: 0.26 +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Poppler.Structs.Quadrilateral + ( + +-- * Exported types + Quadrilateral(..) , + newZeroQuadrilateral , + noQuadrilateral , + + + -- * Methods +-- ** copy #method:copy# + +#if ENABLE_OVERLOADING + QuadrilateralCopyMethodInfo , +#endif + quadrilateralCopy , + + +-- ** free #method:free# + +#if ENABLE_OVERLOADING + QuadrilateralFreeMethodInfo , +#endif + quadrilateralFree , + + +-- ** new #method:new# + + quadrilateralNew , + + + + + -- * Properties +-- ** p1 #attr:p1# +{- | a 'GI.Poppler.Structs.Point.Point' with the first vertex coordinates +-} + getQuadrilateralP1 , +#if ENABLE_OVERLOADING + quadrilateral_p1 , +#endif + + +-- ** p2 #attr:p2# +{- | a 'GI.Poppler.Structs.Point.Point' with the second vertex coordinates +-} + getQuadrilateralP2 , +#if ENABLE_OVERLOADING + quadrilateral_p2 , +#endif + + +-- ** p3 #attr:p3# +{- | a 'GI.Poppler.Structs.Point.Point' with the third vertex coordinates +-} + getQuadrilateralP3 , +#if ENABLE_OVERLOADING + quadrilateral_p3 , +#endif + + +-- ** p4 #attr:p4# +{- | a 'GI.Poppler.Structs.Point.Point' with the fourth vertex coordinates +-} + getQuadrilateralP4 , +#if ENABLE_OVERLOADING + quadrilateral_p4 , +#endif + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import {-# SOURCE #-} qualified GI.Poppler.Structs.Point as Poppler.Point + +-- | Memory-managed wrapper type. +newtype Quadrilateral = Quadrilateral (ManagedPtr 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 + +-- | Construct a `Quadrilateral` struct initialized to zero. +newZeroQuadrilateral :: MonadIO m => m Quadrilateral +newZeroQuadrilateral = liftIO $ callocBoxedBytes 64 >>= wrapBoxed Quadrilateral + +instance tag ~ 'AttrSet => Constructible Quadrilateral tag where + new _ attrs = do + o <- newZeroQuadrilateral + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `Quadrilateral`. +noQuadrilateral :: Maybe Quadrilateral +noQuadrilateral = Nothing + +{- | +Get the value of the “@p1@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' quadrilateral #p1 +@ +-} +getQuadrilateralP1 :: MonadIO m => Quadrilateral -> m Poppler.Point.Point +getQuadrilateralP1 s = liftIO $ withManagedPtr s $ \ptr -> do + let val = ptr `plusPtr` 0 :: (Ptr Poppler.Point.Point) + val' <- (newBoxed Poppler.Point.Point) val + return val' + +#if ENABLE_OVERLOADING +data QuadrilateralP1FieldInfo +instance AttrInfo QuadrilateralP1FieldInfo where + type AttrAllowedOps QuadrilateralP1FieldInfo = '[ 'AttrGet] + type AttrSetTypeConstraint QuadrilateralP1FieldInfo = (~) (Ptr Poppler.Point.Point) + type AttrBaseTypeConstraint QuadrilateralP1FieldInfo = (~) Quadrilateral + type AttrGetType QuadrilateralP1FieldInfo = Poppler.Point.Point + type AttrLabel QuadrilateralP1FieldInfo = "p1" + type AttrOrigin QuadrilateralP1FieldInfo = Quadrilateral + attrGet _ = getQuadrilateralP1 + attrSet _ = undefined + attrConstruct = undefined + attrClear _ = undefined + +quadrilateral_p1 :: AttrLabelProxy "p1" +quadrilateral_p1 = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@p2@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' quadrilateral #p2 +@ +-} +getQuadrilateralP2 :: MonadIO m => Quadrilateral -> m Poppler.Point.Point +getQuadrilateralP2 s = liftIO $ withManagedPtr s $ \ptr -> do + let val = ptr `plusPtr` 16 :: (Ptr Poppler.Point.Point) + val' <- (newBoxed Poppler.Point.Point) val + return val' + +#if ENABLE_OVERLOADING +data QuadrilateralP2FieldInfo +instance AttrInfo QuadrilateralP2FieldInfo where + type AttrAllowedOps QuadrilateralP2FieldInfo = '[ 'AttrGet] + type AttrSetTypeConstraint QuadrilateralP2FieldInfo = (~) (Ptr Poppler.Point.Point) + type AttrBaseTypeConstraint QuadrilateralP2FieldInfo = (~) Quadrilateral + type AttrGetType QuadrilateralP2FieldInfo = Poppler.Point.Point + type AttrLabel QuadrilateralP2FieldInfo = "p2" + type AttrOrigin QuadrilateralP2FieldInfo = Quadrilateral + attrGet _ = getQuadrilateralP2 + attrSet _ = undefined + attrConstruct = undefined + attrClear _ = undefined + +quadrilateral_p2 :: AttrLabelProxy "p2" +quadrilateral_p2 = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@p3@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' quadrilateral #p3 +@ +-} +getQuadrilateralP3 :: MonadIO m => Quadrilateral -> m Poppler.Point.Point +getQuadrilateralP3 s = liftIO $ withManagedPtr s $ \ptr -> do + let val = ptr `plusPtr` 32 :: (Ptr Poppler.Point.Point) + val' <- (newBoxed Poppler.Point.Point) val + return val' + +#if ENABLE_OVERLOADING +data QuadrilateralP3FieldInfo +instance AttrInfo QuadrilateralP3FieldInfo where + type AttrAllowedOps QuadrilateralP3FieldInfo = '[ 'AttrGet] + type AttrSetTypeConstraint QuadrilateralP3FieldInfo = (~) (Ptr Poppler.Point.Point) + type AttrBaseTypeConstraint QuadrilateralP3FieldInfo = (~) Quadrilateral + type AttrGetType QuadrilateralP3FieldInfo = Poppler.Point.Point + type AttrLabel QuadrilateralP3FieldInfo = "p3" + type AttrOrigin QuadrilateralP3FieldInfo = Quadrilateral + attrGet _ = getQuadrilateralP3 + attrSet _ = undefined + attrConstruct = undefined + attrClear _ = undefined + +quadrilateral_p3 :: AttrLabelProxy "p3" +quadrilateral_p3 = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@p4@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' quadrilateral #p4 +@ +-} +getQuadrilateralP4 :: MonadIO m => Quadrilateral -> m Poppler.Point.Point +getQuadrilateralP4 s = liftIO $ withManagedPtr s $ \ptr -> do + let val = ptr `plusPtr` 48 :: (Ptr Poppler.Point.Point) + val' <- (newBoxed Poppler.Point.Point) val + return val' + +#if ENABLE_OVERLOADING +data QuadrilateralP4FieldInfo +instance AttrInfo QuadrilateralP4FieldInfo where + type AttrAllowedOps QuadrilateralP4FieldInfo = '[ 'AttrGet] + type AttrSetTypeConstraint QuadrilateralP4FieldInfo = (~) (Ptr Poppler.Point.Point) + type AttrBaseTypeConstraint QuadrilateralP4FieldInfo = (~) Quadrilateral + type AttrGetType QuadrilateralP4FieldInfo = Poppler.Point.Point + type AttrLabel QuadrilateralP4FieldInfo = "p4" + type AttrOrigin QuadrilateralP4FieldInfo = Quadrilateral + attrGet _ = getQuadrilateralP4 + attrSet _ = undefined + attrConstruct = undefined + attrClear _ = undefined + +quadrilateral_p4 :: AttrLabelProxy "p4" +quadrilateral_p4 = AttrLabelProxy + +#endif + + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList Quadrilateral +type instance O.AttributeList Quadrilateral = QuadrilateralAttributeList +type QuadrilateralAttributeList = ('[ '("p1", QuadrilateralP1FieldInfo), '("p2", QuadrilateralP2FieldInfo), '("p3", QuadrilateralP3FieldInfo), '("p4", QuadrilateralP4FieldInfo)] :: [(Symbol, *)]) +#endif + +-- method Quadrilateral::new +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "Quadrilateral"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_quadrilateral_new" poppler_quadrilateral_new :: + IO (Ptr Quadrilateral) + +{- | +Creates a new 'GI.Poppler.Structs.Quadrilateral.Quadrilateral'. It must be freed with 'GI.Poppler.Structs.Quadrilateral.quadrilateralFree' after use. + +/Since: 0.26/ +-} +quadrilateralNew :: + (B.CallStack.HasCallStack, MonadIO m) => + m Quadrilateral + {- ^ __Returns:__ a new 'GI.Poppler.Structs.Quadrilateral.Quadrilateral'. -} +quadrilateralNew = liftIO $ do + result <- poppler_quadrilateral_new + checkUnexpectedReturnNULL "quadrilateralNew" result + result' <- (wrapBoxed Quadrilateral) result + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method Quadrilateral::copy +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "quad", argType = TInterface (Name {namespace = "Poppler", name = "Quadrilateral"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerQuadrilateral to copy", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "Quadrilateral"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_quadrilateral_copy" poppler_quadrilateral_copy :: + Ptr Quadrilateral -> -- quad : TInterface (Name {namespace = "Poppler", name = "Quadrilateral"}) + IO (Ptr Quadrilateral) + +{- | +Creates a copy of /@quad@/. The copy must be freed with 'GI.Poppler.Structs.Quadrilateral.quadrilateralFree' after use. + +/Since: 0.26/ +-} +quadrilateralCopy :: + (B.CallStack.HasCallStack, MonadIO m) => + Quadrilateral + {- ^ /@quad@/: a 'GI.Poppler.Structs.Quadrilateral.Quadrilateral' to copy -} + -> m Quadrilateral + {- ^ __Returns:__ a new allocated copy of /@quad@/ -} +quadrilateralCopy quad = liftIO $ do + quad' <- unsafeManagedPtrGetPtr quad + result <- poppler_quadrilateral_copy quad' + checkUnexpectedReturnNULL "quadrilateralCopy" result + result' <- (wrapBoxed Quadrilateral) result + touchManagedPtr quad + return result' + +#if ENABLE_OVERLOADING +data QuadrilateralCopyMethodInfo +instance (signature ~ (m Quadrilateral), MonadIO m) => O.MethodInfo QuadrilateralCopyMethodInfo Quadrilateral signature where + overloadedMethod _ = quadrilateralCopy + +#endif + +-- method Quadrilateral::free +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "quad", argType = TInterface (Name {namespace = "Poppler", name = "Quadrilateral"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerQuadrilateral", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_quadrilateral_free" poppler_quadrilateral_free :: + Ptr Quadrilateral -> -- quad : TInterface (Name {namespace = "Poppler", name = "Quadrilateral"}) + IO () + +{- | +Frees the memory used by /@quad@/ + +/Since: 0.26/ +-} +quadrilateralFree :: + (B.CallStack.HasCallStack, MonadIO m) => + Quadrilateral + {- ^ /@quad@/: a 'GI.Poppler.Structs.Quadrilateral.Quadrilateral' -} + -> m () +quadrilateralFree quad = liftIO $ do + quad' <- unsafeManagedPtrGetPtr quad + poppler_quadrilateral_free quad' + touchManagedPtr quad + return () + +#if ENABLE_OVERLOADING +data QuadrilateralFreeMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo QuadrilateralFreeMethodInfo Quadrilateral signature where + overloadedMethod _ = quadrilateralFree + +#endif + +#if ENABLE_OVERLOADING +type family ResolveQuadrilateralMethod (t :: Symbol) (o :: *) :: * where + ResolveQuadrilateralMethod "copy" o = QuadrilateralCopyMethodInfo + ResolveQuadrilateralMethod "free" o = QuadrilateralFreeMethodInfo + ResolveQuadrilateralMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveQuadrilateralMethod t Quadrilateral, O.MethodInfo info Quadrilateral p) => OL.IsLabel t (Quadrilateral -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + 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,32 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Poppler.Structs.Quadrilateral where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype Quadrilateral = Quadrilateral (ManagedPtr Quadrilateral) +instance BoxedObject Quadrilateral where +#if ENABLE_OVERLOADING +data QuadrilateralCopyMethodInfo +#endif +#if ENABLE_OVERLOADING +data QuadrilateralFreeMethodInfo +#endif 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,443 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +A 'GI.Poppler.Structs.Rectangle.Rectangle' is used to describe +locations on a page and bounding boxes +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Poppler.Structs.Rectangle + ( + +-- * Exported types + Rectangle(..) , + newZeroRectangle , + noRectangle , + + + -- * Methods +-- ** copy #method:copy# + +#if ENABLE_OVERLOADING + RectangleCopyMethodInfo , +#endif + rectangleCopy , + + +-- ** free #method:free# + +#if ENABLE_OVERLOADING + RectangleFreeMethodInfo , +#endif + rectangleFree , + + +-- ** new #method:new# + + rectangleNew , + + + + + -- * Properties +-- ** x1 #attr:x1# +{- | x coordinate of lower left corner +-} + getRectangleX1 , +#if ENABLE_OVERLOADING + rectangle_x1 , +#endif + setRectangleX1 , + + +-- ** x2 #attr:x2# +{- | x coordinate of upper right corner +-} + getRectangleX2 , +#if ENABLE_OVERLOADING + rectangle_x2 , +#endif + setRectangleX2 , + + +-- ** y1 #attr:y1# +{- | y coordinate of lower left corner +-} + getRectangleY1 , +#if ENABLE_OVERLOADING + rectangle_y1 , +#endif + setRectangleY1 , + + +-- ** y2 #attr:y2# +{- | y coordinate of upper right corner +-} + getRectangleY2 , +#if ENABLE_OVERLOADING + rectangle_y2 , +#endif + setRectangleY2 , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + + +-- | Memory-managed wrapper type. +newtype Rectangle = Rectangle (ManagedPtr 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 + +-- | Construct a `Rectangle` struct initialized to zero. +newZeroRectangle :: MonadIO m => m Rectangle +newZeroRectangle = liftIO $ callocBoxedBytes 32 >>= wrapBoxed Rectangle + +instance tag ~ 'AttrSet => Constructible Rectangle tag where + new _ attrs = do + o <- newZeroRectangle + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `Rectangle`. +noRectangle :: Maybe Rectangle +noRectangle = Nothing + +{- | +Get the value of the “@x1@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' rectangle #x1 +@ +-} +getRectangleX1 :: MonadIO m => Rectangle -> m Double +getRectangleX1 s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO CDouble + let val' = realToFrac val + return val' + +{- | +Set the value of the “@x1@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' rectangle [ #x1 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setRectangleX1 :: MonadIO m => Rectangle -> Double -> m () +setRectangleX1 s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = realToFrac val + poke (ptr `plusPtr` 0) (val' :: CDouble) + +#if ENABLE_OVERLOADING +data RectangleX1FieldInfo +instance AttrInfo RectangleX1FieldInfo where + type AttrAllowedOps RectangleX1FieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint RectangleX1FieldInfo = (~) Double + type AttrBaseTypeConstraint RectangleX1FieldInfo = (~) Rectangle + type AttrGetType RectangleX1FieldInfo = Double + type AttrLabel RectangleX1FieldInfo = "x1" + type AttrOrigin RectangleX1FieldInfo = Rectangle + attrGet _ = getRectangleX1 + attrSet _ = setRectangleX1 + attrConstruct = undefined + attrClear _ = undefined + +rectangle_x1 :: AttrLabelProxy "x1" +rectangle_x1 = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@y1@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' rectangle #y1 +@ +-} +getRectangleY1 :: MonadIO m => Rectangle -> m Double +getRectangleY1 s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 8) :: IO CDouble + let val' = realToFrac val + return val' + +{- | +Set the value of the “@y1@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' rectangle [ #y1 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setRectangleY1 :: MonadIO m => Rectangle -> Double -> m () +setRectangleY1 s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = realToFrac val + poke (ptr `plusPtr` 8) (val' :: CDouble) + +#if ENABLE_OVERLOADING +data RectangleY1FieldInfo +instance AttrInfo RectangleY1FieldInfo where + type AttrAllowedOps RectangleY1FieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint RectangleY1FieldInfo = (~) Double + type AttrBaseTypeConstraint RectangleY1FieldInfo = (~) Rectangle + type AttrGetType RectangleY1FieldInfo = Double + type AttrLabel RectangleY1FieldInfo = "y1" + type AttrOrigin RectangleY1FieldInfo = Rectangle + attrGet _ = getRectangleY1 + attrSet _ = setRectangleY1 + attrConstruct = undefined + attrClear _ = undefined + +rectangle_y1 :: AttrLabelProxy "y1" +rectangle_y1 = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@x2@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' rectangle #x2 +@ +-} +getRectangleX2 :: MonadIO m => Rectangle -> m Double +getRectangleX2 s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 16) :: IO CDouble + let val' = realToFrac val + return val' + +{- | +Set the value of the “@x2@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' rectangle [ #x2 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setRectangleX2 :: MonadIO m => Rectangle -> Double -> m () +setRectangleX2 s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = realToFrac val + poke (ptr `plusPtr` 16) (val' :: CDouble) + +#if ENABLE_OVERLOADING +data RectangleX2FieldInfo +instance AttrInfo RectangleX2FieldInfo where + type AttrAllowedOps RectangleX2FieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint RectangleX2FieldInfo = (~) Double + type AttrBaseTypeConstraint RectangleX2FieldInfo = (~) Rectangle + type AttrGetType RectangleX2FieldInfo = Double + type AttrLabel RectangleX2FieldInfo = "x2" + type AttrOrigin RectangleX2FieldInfo = Rectangle + attrGet _ = getRectangleX2 + attrSet _ = setRectangleX2 + attrConstruct = undefined + attrClear _ = undefined + +rectangle_x2 :: AttrLabelProxy "x2" +rectangle_x2 = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@y2@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' rectangle #y2 +@ +-} +getRectangleY2 :: MonadIO m => Rectangle -> m Double +getRectangleY2 s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 24) :: IO CDouble + let val' = realToFrac val + return val' + +{- | +Set the value of the “@y2@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' rectangle [ #y2 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setRectangleY2 :: MonadIO m => Rectangle -> Double -> m () +setRectangleY2 s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = realToFrac val + poke (ptr `plusPtr` 24) (val' :: CDouble) + +#if ENABLE_OVERLOADING +data RectangleY2FieldInfo +instance AttrInfo RectangleY2FieldInfo where + type AttrAllowedOps RectangleY2FieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint RectangleY2FieldInfo = (~) Double + type AttrBaseTypeConstraint RectangleY2FieldInfo = (~) Rectangle + type AttrGetType RectangleY2FieldInfo = Double + type AttrLabel RectangleY2FieldInfo = "y2" + type AttrOrigin RectangleY2FieldInfo = Rectangle + attrGet _ = getRectangleY2 + attrSet _ = setRectangleY2 + attrConstruct = undefined + attrClear _ = undefined + +rectangle_y2 :: AttrLabelProxy "y2" +rectangle_y2 = AttrLabelProxy + +#endif + + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList Rectangle +type instance O.AttributeList Rectangle = RectangleAttributeList +type RectangleAttributeList = ('[ '("x1", RectangleX1FieldInfo), '("y1", RectangleY1FieldInfo), '("x2", RectangleX2FieldInfo), '("y2", RectangleY2FieldInfo)] :: [(Symbol, *)]) +#endif + +-- method Rectangle::new +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "Rectangle"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_rectangle_new" poppler_rectangle_new :: + IO (Ptr Rectangle) + +{- | +Creates a new 'GI.Poppler.Structs.Rectangle.Rectangle' +-} +rectangleNew :: + (B.CallStack.HasCallStack, MonadIO m) => + m Rectangle + {- ^ __Returns:__ a new 'GI.Poppler.Structs.Rectangle.Rectangle', use 'GI.Poppler.Structs.Rectangle.rectangleFree' to free it -} +rectangleNew = liftIO $ do + result <- poppler_rectangle_new + checkUnexpectedReturnNULL "rectangleNew" result + result' <- (wrapBoxed Rectangle) result + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method Rectangle::copy +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "rectangle", argType = TInterface (Name {namespace = "Poppler", name = "Rectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerRectangle to copy", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "Rectangle"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_rectangle_copy" poppler_rectangle_copy :: + Ptr Rectangle -> -- rectangle : TInterface (Name {namespace = "Poppler", name = "Rectangle"}) + IO (Ptr Rectangle) + +{- | +Creates a copy of /@rectangle@/ +-} +rectangleCopy :: + (B.CallStack.HasCallStack, MonadIO m) => + Rectangle + {- ^ /@rectangle@/: a 'GI.Poppler.Structs.Rectangle.Rectangle' to copy -} + -> m Rectangle + {- ^ __Returns:__ a new allocated copy of /@rectangle@/ -} +rectangleCopy rectangle = liftIO $ do + rectangle' <- unsafeManagedPtrGetPtr rectangle + result <- poppler_rectangle_copy rectangle' + checkUnexpectedReturnNULL "rectangleCopy" result + result' <- (wrapBoxed Rectangle) result + touchManagedPtr rectangle + return result' + +#if ENABLE_OVERLOADING +data RectangleCopyMethodInfo +instance (signature ~ (m Rectangle), MonadIO m) => O.MethodInfo RectangleCopyMethodInfo Rectangle signature where + overloadedMethod _ = rectangleCopy + +#endif + +-- method Rectangle::free +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "rectangle", argType = TInterface (Name {namespace = "Poppler", name = "Rectangle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerRectangle", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_rectangle_free" poppler_rectangle_free :: + Ptr Rectangle -> -- rectangle : TInterface (Name {namespace = "Poppler", name = "Rectangle"}) + IO () + +{- | +Frees the given 'GI.Poppler.Structs.Rectangle.Rectangle' +-} +rectangleFree :: + (B.CallStack.HasCallStack, MonadIO m) => + Rectangle + {- ^ /@rectangle@/: a 'GI.Poppler.Structs.Rectangle.Rectangle' -} + -> m () +rectangleFree rectangle = liftIO $ do + rectangle' <- unsafeManagedPtrGetPtr rectangle + poppler_rectangle_free rectangle' + touchManagedPtr rectangle + return () + +#if ENABLE_OVERLOADING +data RectangleFreeMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo RectangleFreeMethodInfo Rectangle signature where + overloadedMethod _ = rectangleFree + +#endif + +#if ENABLE_OVERLOADING +type family ResolveRectangleMethod (t :: Symbol) (o :: *) :: * where + ResolveRectangleMethod "copy" o = RectangleCopyMethodInfo + ResolveRectangleMethod "free" o = RectangleFreeMethodInfo + ResolveRectangleMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveRectangleMethod t Rectangle, O.MethodInfo info Rectangle p) => OL.IsLabel t (Rectangle -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + 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,32 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Poppler.Structs.Rectangle where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype Rectangle = Rectangle (ManagedPtr Rectangle) +instance BoxedObject Rectangle where +#if ENABLE_OVERLOADING +data RectangleCopyMethodInfo +#endif +#if ENABLE_OVERLOADING +data RectangleFreeMethodInfo +#endif 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,386 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Poppler.Structs.StructureElementIter + ( + +-- * Exported types + StructureElementIter(..) , + noStructureElementIter , + + + -- * Methods +-- ** copy #method:copy# + +#if ENABLE_OVERLOADING + StructureElementIterCopyMethodInfo , +#endif + structureElementIterCopy , + + +-- ** free #method:free# + +#if ENABLE_OVERLOADING + StructureElementIterFreeMethodInfo , +#endif + structureElementIterFree , + + +-- ** getChild #method:getChild# + +#if ENABLE_OVERLOADING + StructureElementIterGetChildMethodInfo , +#endif + structureElementIterGetChild , + + +-- ** getElement #method:getElement# + +#if ENABLE_OVERLOADING + StructureElementIterGetElementMethodInfo, +#endif + structureElementIterGetElement , + + +-- ** new #method:new# + + structureElementIterNew , + + +-- ** next #method:next# + +#if ENABLE_OVERLOADING + StructureElementIterNextMethodInfo , +#endif + structureElementIterNext , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import {-# SOURCE #-} qualified GI.Poppler.Objects.Document as Poppler.Document +import {-# SOURCE #-} qualified GI.Poppler.Objects.StructureElement as Poppler.StructureElement + +-- | Memory-managed wrapper type. +newtype StructureElementIter = StructureElementIter (ManagedPtr 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 + +-- | A convenience alias for `Nothing` :: `Maybe` `StructureElementIter`. +noStructureElementIter :: Maybe StructureElementIter +noStructureElementIter = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList StructureElementIter +type instance O.AttributeList StructureElementIter = StructureElementIterAttributeList +type StructureElementIterAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method StructureElementIter::new +-- method type : Constructor +-- Args : [Arg {argCName = "poppler_document", argType = TInterface (Name {namespace = "Poppler", name = "Document"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerDocument.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "StructureElementIter"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_structure_element_iter_new" poppler_structure_element_iter_new :: + Ptr Poppler.Document.Document -> -- poppler_document : TInterface (Name {namespace = "Poppler", name = "Document"}) + IO (Ptr StructureElementIter) + +{- | +Returns the root 'GI.Poppler.Structs.StructureElementIter.StructureElementIter' for /@document@/, or 'Nothing'. The +returned value must be freed with 'GI.Poppler.Structs.StructureElementIter.structureElementIterFree'. + +Documents may have an associated structure tree &mdashmostly, Tagged-PDF +compliant documents— which can be used to obtain information about +the document structure and its contents. Each node in the tree contains +a 'GI.Poppler.Objects.StructureElement.StructureElement'. + +Here is a simple example that walks the whole tree: + +\\ +static void +walk_structure (PopplerStructureElementIter *iter) +{ + do { + \/\* Get the element and do something with it *\\/ + PopplerStructureElementIter *child = poppler_structure_element_iter_get_child (iter); + if (child) + walk_structure (child); + poppler_structure_element_iter_free (child); + } while (poppler_structure_element_iter_next (iter)); +} +... +{ + iter = poppler_structure_element_iter_new (document); + walk_structure (iter); + poppler_structure_element_iter_free (iter); +} +\<\/programlisting>\<\/informalexample> + +/Since: 0.26/ +-} +structureElementIterNew :: + (B.CallStack.HasCallStack, MonadIO m, Poppler.Document.IsDocument a) => + a + {- ^ /@popplerDocument@/: a 'GI.Poppler.Objects.Document.Document'. -} + -> m StructureElementIter + {- ^ __Returns:__ a new 'GI.Poppler.Structs.StructureElementIter.StructureElementIter', or 'Nothing' if document + doesn\'t have structure tree. -} +structureElementIterNew popplerDocument = liftIO $ do + popplerDocument' <- unsafeManagedPtrCastPtr popplerDocument + result <- poppler_structure_element_iter_new popplerDocument' + checkUnexpectedReturnNULL "structureElementIterNew" result + result' <- (wrapBoxed StructureElementIter) result + touchManagedPtr popplerDocument + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method StructureElementIter::copy +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "iter", argType = TInterface (Name {namespace = "Poppler", name = "StructureElementIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerStructureElementIter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "StructureElementIter"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_structure_element_iter_copy" poppler_structure_element_iter_copy :: + Ptr StructureElementIter -> -- iter : TInterface (Name {namespace = "Poppler", name = "StructureElementIter"}) + IO (Ptr StructureElementIter) + +{- | +Creates a new 'GI.Poppler.Structs.StructureElementIter.StructureElementIter' as a copy of /@iter@/. The +returned value must be freed with 'GI.Poppler.Structs.StructureElementIter.structureElementIterFree'. + +/Since: 0.26/ +-} +structureElementIterCopy :: + (B.CallStack.HasCallStack, MonadIO m) => + StructureElementIter + {- ^ /@iter@/: a 'GI.Poppler.Structs.StructureElementIter.StructureElementIter' -} + -> m StructureElementIter + {- ^ __Returns:__ a new 'GI.Poppler.Structs.StructureElementIter.StructureElementIter' -} +structureElementIterCopy iter = liftIO $ do + iter' <- unsafeManagedPtrGetPtr iter + result <- poppler_structure_element_iter_copy iter' + checkUnexpectedReturnNULL "structureElementIterCopy" result + result' <- (wrapBoxed StructureElementIter) result + touchManagedPtr iter + return result' + +#if ENABLE_OVERLOADING +data StructureElementIterCopyMethodInfo +instance (signature ~ (m StructureElementIter), MonadIO m) => O.MethodInfo StructureElementIterCopyMethodInfo StructureElementIter signature where + overloadedMethod _ = structureElementIterCopy + +#endif + +-- method StructureElementIter::free +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "iter", argType = TInterface (Name {namespace = "Poppler", name = "StructureElementIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerStructureElementIter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_structure_element_iter_free" poppler_structure_element_iter_free :: + Ptr StructureElementIter -> -- iter : TInterface (Name {namespace = "Poppler", name = "StructureElementIter"}) + IO () + +{- | +Frees /@iter@/. + +/Since: 0.26/ +-} +structureElementIterFree :: + (B.CallStack.HasCallStack, MonadIO m) => + StructureElementIter + {- ^ /@iter@/: a 'GI.Poppler.Structs.StructureElementIter.StructureElementIter' -} + -> m () +structureElementIterFree iter = liftIO $ do + iter' <- unsafeManagedPtrGetPtr iter + poppler_structure_element_iter_free iter' + touchManagedPtr iter + return () + +#if ENABLE_OVERLOADING +data StructureElementIterFreeMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo StructureElementIterFreeMethodInfo StructureElementIter signature where + overloadedMethod _ = structureElementIterFree + +#endif + +-- method StructureElementIter::get_child +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "parent", argType = TInterface (Name {namespace = "Poppler", name = "StructureElementIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerStructureElementIter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "StructureElementIter"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_structure_element_iter_get_child" poppler_structure_element_iter_get_child :: + Ptr StructureElementIter -> -- parent : TInterface (Name {namespace = "Poppler", name = "StructureElementIter"}) + IO (Ptr StructureElementIter) + +{- | +Returns a new iterator to the children elements of the +'GI.Poppler.Objects.StructureElement.StructureElement' associated with /@iter@/. The returned value must +be freed with 'GI.Poppler.Structs.StructureElementIter.structureElementIterFree'. + +/Since: 0.26/ +-} +structureElementIterGetChild :: + (B.CallStack.HasCallStack, MonadIO m) => + StructureElementIter + {- ^ /@parent@/: a 'GI.Poppler.Structs.StructureElementIter.StructureElementIter' -} + -> m StructureElementIter + {- ^ __Returns:__ a new 'GI.Poppler.Structs.StructureElementIter.StructureElementIter' -} +structureElementIterGetChild parent = liftIO $ do + parent' <- unsafeManagedPtrGetPtr parent + result <- poppler_structure_element_iter_get_child parent' + checkUnexpectedReturnNULL "structureElementIterGetChild" result + result' <- (wrapBoxed StructureElementIter) result + touchManagedPtr parent + return result' + +#if ENABLE_OVERLOADING +data StructureElementIterGetChildMethodInfo +instance (signature ~ (m StructureElementIter), MonadIO m) => O.MethodInfo StructureElementIterGetChildMethodInfo StructureElementIter signature where + overloadedMethod _ = structureElementIterGetChild + +#endif + +-- method StructureElementIter::get_element +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "iter", argType = TInterface (Name {namespace = "Poppler", name = "StructureElementIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerStructureElementIter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "StructureElement"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_structure_element_iter_get_element" poppler_structure_element_iter_get_element :: + Ptr StructureElementIter -> -- iter : TInterface (Name {namespace = "Poppler", name = "StructureElementIter"}) + IO (Ptr Poppler.StructureElement.StructureElement) + +{- | +Returns the 'GI.Poppler.Structs.StructureElementIter.StructureElementIter' associated with /@iter@/. + +/Since: 0.26/ +-} +structureElementIterGetElement :: + (B.CallStack.HasCallStack, MonadIO m) => + StructureElementIter + {- ^ /@iter@/: a 'GI.Poppler.Structs.StructureElementIter.StructureElementIter' -} + -> m Poppler.StructureElement.StructureElement + {- ^ __Returns:__ a new 'GI.Poppler.Structs.StructureElementIter.StructureElementIter' -} +structureElementIterGetElement iter = liftIO $ do + iter' <- unsafeManagedPtrGetPtr iter + result <- poppler_structure_element_iter_get_element iter' + checkUnexpectedReturnNULL "structureElementIterGetElement" result + result' <- (wrapObject Poppler.StructureElement.StructureElement) result + touchManagedPtr iter + return result' + +#if ENABLE_OVERLOADING +data StructureElementIterGetElementMethodInfo +instance (signature ~ (m Poppler.StructureElement.StructureElement), MonadIO m) => O.MethodInfo StructureElementIterGetElementMethodInfo StructureElementIter signature where + overloadedMethod _ = structureElementIterGetElement + +#endif + +-- method StructureElementIter::next +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "iter", argType = TInterface (Name {namespace = "Poppler", name = "StructureElementIter"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerStructureElementIter", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_structure_element_iter_next" poppler_structure_element_iter_next :: + Ptr StructureElementIter -> -- iter : TInterface (Name {namespace = "Poppler", name = "StructureElementIter"}) + IO CInt + +{- | +Sets /@iter@/ to point to the next structure element at the current level +of the tree, if valid. See 'GI.Poppler.Structs.StructureElementIter.structureElementIterNew' for more +information. + +/Since: 0.26/ +-} +structureElementIterNext :: + (B.CallStack.HasCallStack, MonadIO m) => + StructureElementIter + {- ^ /@iter@/: a 'GI.Poppler.Structs.StructureElementIter.StructureElementIter' -} + -> m Bool + {- ^ __Returns:__ 'True', if /@iter@/ was set to the next structure element -} +structureElementIterNext iter = liftIO $ do + iter' <- unsafeManagedPtrGetPtr iter + result <- poppler_structure_element_iter_next iter' + let result' = (/= 0) result + touchManagedPtr iter + return result' + +#if ENABLE_OVERLOADING +data StructureElementIterNextMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo StructureElementIterNextMethodInfo StructureElementIter signature where + overloadedMethod _ = structureElementIterNext + +#endif + +#if ENABLE_OVERLOADING +type family ResolveStructureElementIterMethod (t :: Symbol) (o :: *) :: * where + ResolveStructureElementIterMethod "copy" o = StructureElementIterCopyMethodInfo + ResolveStructureElementIterMethod "free" o = StructureElementIterFreeMethodInfo + ResolveStructureElementIterMethod "next" o = StructureElementIterNextMethodInfo + ResolveStructureElementIterMethod "getChild" o = StructureElementIterGetChildMethodInfo + ResolveStructureElementIterMethod "getElement" o = StructureElementIterGetElementMethodInfo + ResolveStructureElementIterMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveStructureElementIterMethod t StructureElementIter, O.MethodInfo info StructureElementIter p) => OL.IsLabel t (StructureElementIter -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + 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,41 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Poppler.Structs.StructureElementIter where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype StructureElementIter = StructureElementIter (ManagedPtr StructureElementIter) +instance BoxedObject StructureElementIter where +#if ENABLE_OVERLOADING +data StructureElementIterCopyMethodInfo +#endif +#if ENABLE_OVERLOADING +data StructureElementIterFreeMethodInfo +#endif +#if ENABLE_OVERLOADING +data StructureElementIterGetChildMethodInfo +#endif +#if ENABLE_OVERLOADING +data StructureElementIterGetElementMethodInfo +#endif +#if ENABLE_OVERLOADING +data StructureElementIterNextMethodInfo +#endif 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,561 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +A 'GI.Poppler.Structs.TextAttributes.TextAttributes' is used to describe text attributes of a range of text + +/Since: 0.18/ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Poppler.Structs.TextAttributes + ( + +-- * Exported types + TextAttributes(..) , + newZeroTextAttributes , + noTextAttributes , + + + -- * Methods +-- ** copy #method:copy# + +#if ENABLE_OVERLOADING + TextAttributesCopyMethodInfo , +#endif + textAttributesCopy , + + +-- ** free #method:free# + +#if ENABLE_OVERLOADING + TextAttributesFreeMethodInfo , +#endif + textAttributesFree , + + +-- ** new #method:new# + + textAttributesNew , + + + + + -- * Properties +-- ** color #attr:color# +{- | a 'GI.Poppler.Structs.Color.Color', the foreground color +-} + getTextAttributesColor , +#if ENABLE_OVERLOADING + textAttributes_color , +#endif + + +-- ** endIndex #attr:endIndex# +{- | end position this text attributes apply +-} + getTextAttributesEndIndex , + setTextAttributesEndIndex , +#if ENABLE_OVERLOADING + textAttributes_endIndex , +#endif + + +-- ** fontName #attr:fontName# +{- | font name +-} + clearTextAttributesFontName , + getTextAttributesFontName , + setTextAttributesFontName , +#if ENABLE_OVERLOADING + textAttributes_fontName , +#endif + + +-- ** fontSize #attr:fontSize# +{- | font size +-} + getTextAttributesFontSize , + setTextAttributesFontSize , +#if ENABLE_OVERLOADING + textAttributes_fontSize , +#endif + + +-- ** isUnderlined #attr:isUnderlined# +{- | if text is underlined +-} + getTextAttributesIsUnderlined , + setTextAttributesIsUnderlined , +#if ENABLE_OVERLOADING + textAttributes_isUnderlined , +#endif + + +-- ** startIndex #attr:startIndex# +{- | start position this text attributes apply +-} + getTextAttributesStartIndex , + setTextAttributesStartIndex , +#if ENABLE_OVERLOADING + textAttributes_startIndex , +#endif + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import {-# SOURCE #-} qualified GI.Poppler.Structs.Color as Poppler.Color + +-- | Memory-managed wrapper type. +newtype TextAttributes = TextAttributes (ManagedPtr 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 + +-- | Construct a `TextAttributes` struct initialized to zero. +newZeroTextAttributes :: MonadIO m => m TextAttributes +newZeroTextAttributes = liftIO $ callocBoxedBytes 40 >>= wrapBoxed TextAttributes + +instance tag ~ 'AttrSet => Constructible TextAttributes tag where + new _ attrs = do + o <- newZeroTextAttributes + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `TextAttributes`. +noTextAttributes :: Maybe TextAttributes +noTextAttributes = Nothing + +{- | +Get the value of the “@font_name@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' textAttributes #fontName +@ +-} +getTextAttributesFontName :: MonadIO m => TextAttributes -> m (Maybe T.Text) +getTextAttributesFontName s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO CString + result <- SP.convertIfNonNull val $ \val' -> do + val'' <- cstringToText val' + return val'' + return result + +{- | +Set the value of the “@font_name@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' textAttributes [ #fontName 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setTextAttributesFontName :: MonadIO m => TextAttributes -> CString -> m () +setTextAttributesFontName s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 0) (val :: CString) + +{- | +Set the value of the “@font_name@” field to `Nothing`. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.clear' #fontName +@ +-} +clearTextAttributesFontName :: MonadIO m => TextAttributes -> m () +clearTextAttributesFontName s = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 0) (FP.nullPtr :: CString) + +#if ENABLE_OVERLOADING +data TextAttributesFontNameFieldInfo +instance AttrInfo TextAttributesFontNameFieldInfo where + type AttrAllowedOps TextAttributesFontNameFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear] + type AttrSetTypeConstraint TextAttributesFontNameFieldInfo = (~) CString + type AttrBaseTypeConstraint TextAttributesFontNameFieldInfo = (~) TextAttributes + type AttrGetType TextAttributesFontNameFieldInfo = Maybe T.Text + type AttrLabel TextAttributesFontNameFieldInfo = "font_name" + type AttrOrigin TextAttributesFontNameFieldInfo = TextAttributes + attrGet _ = getTextAttributesFontName + attrSet _ = setTextAttributesFontName + attrConstruct = undefined + attrClear _ = clearTextAttributesFontName + +textAttributes_fontName :: AttrLabelProxy "fontName" +textAttributes_fontName = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@font_size@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' textAttributes #fontSize +@ +-} +getTextAttributesFontSize :: MonadIO m => TextAttributes -> m Double +getTextAttributesFontSize s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 8) :: IO CDouble + let val' = realToFrac val + return val' + +{- | +Set the value of the “@font_size@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' textAttributes [ #fontSize 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setTextAttributesFontSize :: MonadIO m => TextAttributes -> Double -> m () +setTextAttributesFontSize s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = realToFrac val + poke (ptr `plusPtr` 8) (val' :: CDouble) + +#if ENABLE_OVERLOADING +data TextAttributesFontSizeFieldInfo +instance AttrInfo TextAttributesFontSizeFieldInfo where + type AttrAllowedOps TextAttributesFontSizeFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint TextAttributesFontSizeFieldInfo = (~) Double + type AttrBaseTypeConstraint TextAttributesFontSizeFieldInfo = (~) TextAttributes + type AttrGetType TextAttributesFontSizeFieldInfo = Double + type AttrLabel TextAttributesFontSizeFieldInfo = "font_size" + type AttrOrigin TextAttributesFontSizeFieldInfo = TextAttributes + attrGet _ = getTextAttributesFontSize + attrSet _ = setTextAttributesFontSize + attrConstruct = undefined + attrClear _ = undefined + +textAttributes_fontSize :: AttrLabelProxy "fontSize" +textAttributes_fontSize = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@is_underlined@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' textAttributes #isUnderlined +@ +-} +getTextAttributesIsUnderlined :: MonadIO m => TextAttributes -> m Bool +getTextAttributesIsUnderlined s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 16) :: IO CInt + let val' = (/= 0) val + return val' + +{- | +Set the value of the “@is_underlined@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' textAttributes [ #isUnderlined 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setTextAttributesIsUnderlined :: MonadIO m => TextAttributes -> Bool -> m () +setTextAttributesIsUnderlined s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = (fromIntegral . fromEnum) val + poke (ptr `plusPtr` 16) (val' :: CInt) + +#if ENABLE_OVERLOADING +data TextAttributesIsUnderlinedFieldInfo +instance AttrInfo TextAttributesIsUnderlinedFieldInfo where + type AttrAllowedOps TextAttributesIsUnderlinedFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint TextAttributesIsUnderlinedFieldInfo = (~) Bool + type AttrBaseTypeConstraint TextAttributesIsUnderlinedFieldInfo = (~) TextAttributes + type AttrGetType TextAttributesIsUnderlinedFieldInfo = Bool + type AttrLabel TextAttributesIsUnderlinedFieldInfo = "is_underlined" + type AttrOrigin TextAttributesIsUnderlinedFieldInfo = TextAttributes + attrGet _ = getTextAttributesIsUnderlined + attrSet _ = setTextAttributesIsUnderlined + attrConstruct = undefined + attrClear _ = undefined + +textAttributes_isUnderlined :: AttrLabelProxy "isUnderlined" +textAttributes_isUnderlined = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@color@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' textAttributes #color +@ +-} +getTextAttributesColor :: MonadIO m => TextAttributes -> m Poppler.Color.Color +getTextAttributesColor s = liftIO $ withManagedPtr s $ \ptr -> do + let val = ptr `plusPtr` 20 :: (Ptr Poppler.Color.Color) + val' <- (newBoxed Poppler.Color.Color) val + return val' + +#if ENABLE_OVERLOADING +data TextAttributesColorFieldInfo +instance AttrInfo TextAttributesColorFieldInfo where + type AttrAllowedOps TextAttributesColorFieldInfo = '[ 'AttrGet] + type AttrSetTypeConstraint TextAttributesColorFieldInfo = (~) (Ptr Poppler.Color.Color) + type AttrBaseTypeConstraint TextAttributesColorFieldInfo = (~) TextAttributes + type AttrGetType TextAttributesColorFieldInfo = Poppler.Color.Color + type AttrLabel TextAttributesColorFieldInfo = "color" + type AttrOrigin TextAttributesColorFieldInfo = TextAttributes + attrGet _ = getTextAttributesColor + attrSet _ = undefined + attrConstruct = undefined + attrClear _ = undefined + +textAttributes_color :: AttrLabelProxy "color" +textAttributes_color = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@start_index@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' textAttributes #startIndex +@ +-} +getTextAttributesStartIndex :: MonadIO m => TextAttributes -> m Int32 +getTextAttributesStartIndex s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 28) :: IO Int32 + return val + +{- | +Set the value of the “@start_index@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' textAttributes [ #startIndex 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setTextAttributesStartIndex :: MonadIO m => TextAttributes -> Int32 -> m () +setTextAttributesStartIndex s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 28) (val :: Int32) + +#if ENABLE_OVERLOADING +data TextAttributesStartIndexFieldInfo +instance AttrInfo TextAttributesStartIndexFieldInfo where + type AttrAllowedOps TextAttributesStartIndexFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint TextAttributesStartIndexFieldInfo = (~) Int32 + type AttrBaseTypeConstraint TextAttributesStartIndexFieldInfo = (~) TextAttributes + type AttrGetType TextAttributesStartIndexFieldInfo = Int32 + type AttrLabel TextAttributesStartIndexFieldInfo = "start_index" + type AttrOrigin TextAttributesStartIndexFieldInfo = TextAttributes + attrGet _ = getTextAttributesStartIndex + attrSet _ = setTextAttributesStartIndex + attrConstruct = undefined + attrClear _ = undefined + +textAttributes_startIndex :: AttrLabelProxy "startIndex" +textAttributes_startIndex = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@end_index@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' textAttributes #endIndex +@ +-} +getTextAttributesEndIndex :: MonadIO m => TextAttributes -> m Int32 +getTextAttributesEndIndex s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 32) :: IO Int32 + return val + +{- | +Set the value of the “@end_index@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' textAttributes [ #endIndex 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setTextAttributesEndIndex :: MonadIO m => TextAttributes -> Int32 -> m () +setTextAttributesEndIndex s val = liftIO $ withManagedPtr s $ \ptr -> do + poke (ptr `plusPtr` 32) (val :: Int32) + +#if ENABLE_OVERLOADING +data TextAttributesEndIndexFieldInfo +instance AttrInfo TextAttributesEndIndexFieldInfo where + type AttrAllowedOps TextAttributesEndIndexFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint TextAttributesEndIndexFieldInfo = (~) Int32 + type AttrBaseTypeConstraint TextAttributesEndIndexFieldInfo = (~) TextAttributes + type AttrGetType TextAttributesEndIndexFieldInfo = Int32 + type AttrLabel TextAttributesEndIndexFieldInfo = "end_index" + type AttrOrigin TextAttributesEndIndexFieldInfo = TextAttributes + attrGet _ = getTextAttributesEndIndex + attrSet _ = setTextAttributesEndIndex + attrConstruct = undefined + attrClear _ = undefined + +textAttributes_endIndex :: AttrLabelProxy "endIndex" +textAttributes_endIndex = AttrLabelProxy + +#endif + + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList TextAttributes +type instance O.AttributeList TextAttributes = TextAttributesAttributeList +type TextAttributesAttributeList = ('[ '("fontName", TextAttributesFontNameFieldInfo), '("fontSize", TextAttributesFontSizeFieldInfo), '("isUnderlined", TextAttributesIsUnderlinedFieldInfo), '("color", TextAttributesColorFieldInfo), '("startIndex", TextAttributesStartIndexFieldInfo), '("endIndex", TextAttributesEndIndexFieldInfo)] :: [(Symbol, *)]) +#endif + +-- method TextAttributes::new +-- method type : Constructor +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "TextAttributes"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_text_attributes_new" poppler_text_attributes_new :: + IO (Ptr TextAttributes) + +{- | +Creates a new 'GI.Poppler.Structs.TextAttributes.TextAttributes' + +/Since: 0.18/ +-} +textAttributesNew :: + (B.CallStack.HasCallStack, MonadIO m) => + m TextAttributes + {- ^ __Returns:__ a new 'GI.Poppler.Structs.TextAttributes.TextAttributes', use 'GI.Poppler.Structs.TextAttributes.textAttributesFree' to free it -} +textAttributesNew = liftIO $ do + result <- poppler_text_attributes_new + checkUnexpectedReturnNULL "textAttributesNew" result + result' <- (wrapBoxed TextAttributes) result + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method TextAttributes::copy +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "text_attrs", argType = TInterface (Name {namespace = "Poppler", name = "TextAttributes"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerTextAttributes to copy", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "TextAttributes"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_text_attributes_copy" poppler_text_attributes_copy :: + Ptr TextAttributes -> -- text_attrs : TInterface (Name {namespace = "Poppler", name = "TextAttributes"}) + IO (Ptr TextAttributes) + +{- | +Creates a copy of /@textAttrs@/ + +/Since: 0.18/ +-} +textAttributesCopy :: + (B.CallStack.HasCallStack, MonadIO m) => + TextAttributes + {- ^ /@textAttrs@/: a 'GI.Poppler.Structs.TextAttributes.TextAttributes' to copy -} + -> m TextAttributes + {- ^ __Returns:__ a new allocated copy of /@textAttrs@/ -} +textAttributesCopy textAttrs = liftIO $ do + textAttrs' <- unsafeManagedPtrGetPtr textAttrs + result <- poppler_text_attributes_copy textAttrs' + checkUnexpectedReturnNULL "textAttributesCopy" result + result' <- (wrapBoxed TextAttributes) result + touchManagedPtr textAttrs + return result' + +#if ENABLE_OVERLOADING +data TextAttributesCopyMethodInfo +instance (signature ~ (m TextAttributes), MonadIO m) => O.MethodInfo TextAttributesCopyMethodInfo TextAttributes signature where + overloadedMethod _ = textAttributesCopy + +#endif + +-- method TextAttributes::free +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "text_attrs", argType = TInterface (Name {namespace = "Poppler", name = "TextAttributes"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerTextAttributes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_text_attributes_free" poppler_text_attributes_free :: + Ptr TextAttributes -> -- text_attrs : TInterface (Name {namespace = "Poppler", name = "TextAttributes"}) + IO () + +{- | +Frees the given 'GI.Poppler.Structs.TextAttributes.TextAttributes' + +/Since: 0.18/ +-} +textAttributesFree :: + (B.CallStack.HasCallStack, MonadIO m) => + TextAttributes + {- ^ /@textAttrs@/: a 'GI.Poppler.Structs.TextAttributes.TextAttributes' -} + -> m () +textAttributesFree textAttrs = liftIO $ do + textAttrs' <- unsafeManagedPtrGetPtr textAttrs + poppler_text_attributes_free textAttrs' + touchManagedPtr textAttrs + return () + +#if ENABLE_OVERLOADING +data TextAttributesFreeMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo TextAttributesFreeMethodInfo TextAttributes signature where + overloadedMethod _ = textAttributesFree + +#endif + +#if ENABLE_OVERLOADING +type family ResolveTextAttributesMethod (t :: Symbol) (o :: *) :: * where + ResolveTextAttributesMethod "copy" o = TextAttributesCopyMethodInfo + ResolveTextAttributesMethod "free" o = TextAttributesFreeMethodInfo + ResolveTextAttributesMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveTextAttributesMethod t TextAttributes, O.MethodInfo info TextAttributes p) => OL.IsLabel t (TextAttributes -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + 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,32 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Poppler.Structs.TextAttributes where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype TextAttributes = TextAttributes (ManagedPtr TextAttributes) +instance BoxedObject TextAttributes where +#if ENABLE_OVERLOADING +data TextAttributesCopyMethodInfo +#endif +#if ENABLE_OVERLOADING +data TextAttributesFreeMethodInfo +#endif 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,452 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +/No description available in the introspection data./ +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Poppler.Structs.TextSpan + ( + +-- * Exported types + TextSpan(..) , + noTextSpan , + + + -- * Methods +-- ** copy #method:copy# + +#if ENABLE_OVERLOADING + TextSpanCopyMethodInfo , +#endif + textSpanCopy , + + +-- ** free #method:free# + +#if ENABLE_OVERLOADING + TextSpanFreeMethodInfo , +#endif + textSpanFree , + + +-- ** getColor #method:getColor# + +#if ENABLE_OVERLOADING + TextSpanGetColorMethodInfo , +#endif + textSpanGetColor , + + +-- ** getFontName #method:getFontName# + +#if ENABLE_OVERLOADING + TextSpanGetFontNameMethodInfo , +#endif + textSpanGetFontName , + + +-- ** getText #method:getText# + +#if ENABLE_OVERLOADING + TextSpanGetTextMethodInfo , +#endif + textSpanGetText , + + +-- ** isBoldFont #method:isBoldFont# + +#if ENABLE_OVERLOADING + TextSpanIsBoldFontMethodInfo , +#endif + textSpanIsBoldFont , + + +-- ** isFixedWidthFont #method:isFixedWidthFont# + +#if ENABLE_OVERLOADING + TextSpanIsFixedWidthFontMethodInfo , +#endif + textSpanIsFixedWidthFont , + + +-- ** isSerifFont #method:isSerifFont# + +#if ENABLE_OVERLOADING + TextSpanIsSerifFontMethodInfo , +#endif + textSpanIsSerifFont , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import {-# SOURCE #-} qualified GI.Poppler.Structs.Color as Poppler.Color + +-- | Memory-managed wrapper type. +newtype TextSpan = TextSpan (ManagedPtr 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 + +-- | A convenience alias for `Nothing` :: `Maybe` `TextSpan`. +noTextSpan :: Maybe TextSpan +noTextSpan = Nothing + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList TextSpan +type instance O.AttributeList TextSpan = TextSpanAttributeList +type TextSpanAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +-- method TextSpan::copy +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_text_span", argType = TInterface (Name {namespace = "Poppler", name = "TextSpan"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerTextSpan", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "TextSpan"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_text_span_copy" poppler_text_span_copy :: + Ptr TextSpan -> -- poppler_text_span : TInterface (Name {namespace = "Poppler", name = "TextSpan"}) + IO (Ptr TextSpan) + +{- | +Makes a copy of a text span. + +/Since: 0.26/ +-} +textSpanCopy :: + (B.CallStack.HasCallStack, MonadIO m) => + TextSpan + {- ^ /@popplerTextSpan@/: a 'GI.Poppler.Structs.TextSpan.TextSpan' -} + -> m TextSpan + {- ^ __Returns:__ A new 'GI.Poppler.Structs.TextSpan.TextSpan' -} +textSpanCopy popplerTextSpan = liftIO $ do + popplerTextSpan' <- unsafeManagedPtrGetPtr popplerTextSpan + result <- poppler_text_span_copy popplerTextSpan' + checkUnexpectedReturnNULL "textSpanCopy" result + result' <- (wrapBoxed TextSpan) result + touchManagedPtr popplerTextSpan + return result' + +#if ENABLE_OVERLOADING +data TextSpanCopyMethodInfo +instance (signature ~ (m TextSpan), MonadIO m) => O.MethodInfo TextSpanCopyMethodInfo TextSpan signature where + overloadedMethod _ = textSpanCopy + +#endif + +-- method TextSpan::free +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_text_span", argType = TInterface (Name {namespace = "Poppler", name = "TextSpan"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #PopplerTextSpan", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_text_span_free" poppler_text_span_free :: + Ptr TextSpan -> -- poppler_text_span : TInterface (Name {namespace = "Poppler", name = "TextSpan"}) + IO () + +{- | +Frees a text span. + +/Since: 0.26/ +-} +textSpanFree :: + (B.CallStack.HasCallStack, MonadIO m) => + TextSpan + {- ^ /@popplerTextSpan@/: A 'GI.Poppler.Structs.TextSpan.TextSpan' -} + -> m () +textSpanFree popplerTextSpan = liftIO $ do + popplerTextSpan' <- unsafeManagedPtrGetPtr popplerTextSpan + poppler_text_span_free popplerTextSpan' + touchManagedPtr popplerTextSpan + return () + +#if ENABLE_OVERLOADING +data TextSpanFreeMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo TextSpanFreeMethodInfo TextSpan signature where + overloadedMethod _ = textSpanFree + +#endif + +-- method TextSpan::get_color +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_text_span", argType = TInterface (Name {namespace = "Poppler", name = "TextSpan"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerTextSpan", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "color", argType = TInterface (Name {namespace = "Poppler", name = "Color"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a return location for a #PopplerColor", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_text_span_get_color" poppler_text_span_get_color :: + Ptr TextSpan -> -- poppler_text_span : TInterface (Name {namespace = "Poppler", name = "TextSpan"}) + Ptr Poppler.Color.Color -> -- color : TInterface (Name {namespace = "Poppler", name = "Color"}) + IO () + +{- | +Obtains the color in which the text is to be rendered. + +/Since: 0.26/ +-} +textSpanGetColor :: + (B.CallStack.HasCallStack, MonadIO m) => + TextSpan + {- ^ /@popplerTextSpan@/: a 'GI.Poppler.Structs.TextSpan.TextSpan' -} + -> m (Poppler.Color.Color) +textSpanGetColor popplerTextSpan = liftIO $ do + popplerTextSpan' <- unsafeManagedPtrGetPtr popplerTextSpan + color <- callocBoxedBytes 6 :: IO (Ptr Poppler.Color.Color) + poppler_text_span_get_color popplerTextSpan' color + color' <- (wrapBoxed Poppler.Color.Color) color + touchManagedPtr popplerTextSpan + return color' + +#if ENABLE_OVERLOADING +data TextSpanGetColorMethodInfo +instance (signature ~ (m (Poppler.Color.Color)), MonadIO m) => O.MethodInfo TextSpanGetColorMethodInfo TextSpan signature where + overloadedMethod _ = textSpanGetColor + +#endif + +-- method TextSpan::get_font_name +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_text_span", argType = TInterface (Name {namespace = "Poppler", name = "TextSpan"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerTextSpan", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_text_span_get_font_name" poppler_text_span_get_font_name :: + Ptr TextSpan -> -- poppler_text_span : TInterface (Name {namespace = "Poppler", name = "TextSpan"}) + IO CString + +{- | +Obtains the name of the font in which the span is to be rendered. + +/Since: 0.26/ +-} +textSpanGetFontName :: + (B.CallStack.HasCallStack, MonadIO m) => + TextSpan + {- ^ /@popplerTextSpan@/: a 'GI.Poppler.Structs.TextSpan.TextSpan' -} + -> m T.Text + {- ^ __Returns:__ A string containing the font name, or + 'Nothing' if a font is not defined. -} +textSpanGetFontName popplerTextSpan = liftIO $ do + popplerTextSpan' <- unsafeManagedPtrGetPtr popplerTextSpan + result <- poppler_text_span_get_font_name popplerTextSpan' + checkUnexpectedReturnNULL "textSpanGetFontName" result + result' <- cstringToText result + touchManagedPtr popplerTextSpan + return result' + +#if ENABLE_OVERLOADING +data TextSpanGetFontNameMethodInfo +instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo TextSpanGetFontNameMethodInfo TextSpan signature where + overloadedMethod _ = textSpanGetFontName + +#endif + +-- method TextSpan::get_text +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_text_span", argType = TInterface (Name {namespace = "Poppler", name = "TextSpan"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerTextSpan", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUTF8) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_text_span_get_text" poppler_text_span_get_text :: + Ptr TextSpan -> -- poppler_text_span : TInterface (Name {namespace = "Poppler", name = "TextSpan"}) + IO CString + +{- | +Obtains the text contained in the span. + +/Since: 0.26/ +-} +textSpanGetText :: + (B.CallStack.HasCallStack, MonadIO m) => + TextSpan + {- ^ /@popplerTextSpan@/: a 'GI.Poppler.Structs.TextSpan.TextSpan' -} + -> m T.Text + {- ^ __Returns:__ A string. -} +textSpanGetText popplerTextSpan = liftIO $ do + popplerTextSpan' <- unsafeManagedPtrGetPtr popplerTextSpan + result <- poppler_text_span_get_text popplerTextSpan' + checkUnexpectedReturnNULL "textSpanGetText" result + result' <- cstringToText result + touchManagedPtr popplerTextSpan + return result' + +#if ENABLE_OVERLOADING +data TextSpanGetTextMethodInfo +instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo TextSpanGetTextMethodInfo TextSpan signature where + overloadedMethod _ = textSpanGetText + +#endif + +-- method TextSpan::is_bold_font +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_text_span", argType = TInterface (Name {namespace = "Poppler", name = "TextSpan"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerTextSpan", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_text_span_is_bold_font" poppler_text_span_is_bold_font :: + Ptr TextSpan -> -- poppler_text_span : TInterface (Name {namespace = "Poppler", name = "TextSpan"}) + IO CInt + +{- | +Check whether a text span is meant to be rendered using a bold font. + +/Since: 0.26/ +-} +textSpanIsBoldFont :: + (B.CallStack.HasCallStack, MonadIO m) => + TextSpan + {- ^ /@popplerTextSpan@/: a 'GI.Poppler.Structs.TextSpan.TextSpan' -} + -> m Bool + {- ^ __Returns:__ Whether the span uses bold font. -} +textSpanIsBoldFont popplerTextSpan = liftIO $ do + popplerTextSpan' <- unsafeManagedPtrGetPtr popplerTextSpan + result <- poppler_text_span_is_bold_font popplerTextSpan' + let result' = (/= 0) result + touchManagedPtr popplerTextSpan + return result' + +#if ENABLE_OVERLOADING +data TextSpanIsBoldFontMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo TextSpanIsBoldFontMethodInfo TextSpan signature where + overloadedMethod _ = textSpanIsBoldFont + +#endif + +-- method TextSpan::is_fixed_width_font +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_text_span", argType = TInterface (Name {namespace = "Poppler", name = "TextSpan"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerTextSpan", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_text_span_is_fixed_width_font" poppler_text_span_is_fixed_width_font :: + Ptr TextSpan -> -- poppler_text_span : TInterface (Name {namespace = "Poppler", name = "TextSpan"}) + IO CInt + +{- | +Check wether a text span is meant to be rendered using a fixed-width font. + +/Since: 0.26/ +-} +textSpanIsFixedWidthFont :: + (B.CallStack.HasCallStack, MonadIO m) => + TextSpan + {- ^ /@popplerTextSpan@/: a 'GI.Poppler.Structs.TextSpan.TextSpan' -} + -> m Bool + {- ^ __Returns:__ Whether the span uses a fixed-width font. -} +textSpanIsFixedWidthFont popplerTextSpan = liftIO $ do + popplerTextSpan' <- unsafeManagedPtrGetPtr popplerTextSpan + result <- poppler_text_span_is_fixed_width_font popplerTextSpan' + let result' = (/= 0) result + touchManagedPtr popplerTextSpan + return result' + +#if ENABLE_OVERLOADING +data TextSpanIsFixedWidthFontMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo TextSpanIsFixedWidthFontMethodInfo TextSpan signature where + overloadedMethod _ = textSpanIsFixedWidthFont + +#endif + +-- method TextSpan::is_serif_font +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "poppler_text_span", argType = TInterface (Name {namespace = "Poppler", name = "TextSpan"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerTextSpan", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_text_span_is_serif_font" poppler_text_span_is_serif_font :: + Ptr TextSpan -> -- poppler_text_span : TInterface (Name {namespace = "Poppler", name = "TextSpan"}) + IO CInt + +{- | +Check whether a text span is meant to be rendered using a serif font. + +/Since: 0.26/ +-} +textSpanIsSerifFont :: + (B.CallStack.HasCallStack, MonadIO m) => + TextSpan + {- ^ /@popplerTextSpan@/: a 'GI.Poppler.Structs.TextSpan.TextSpan' -} + -> m Bool + {- ^ __Returns:__ Whether the span uses a serif font. -} +textSpanIsSerifFont popplerTextSpan = liftIO $ do + popplerTextSpan' <- unsafeManagedPtrGetPtr popplerTextSpan + result <- poppler_text_span_is_serif_font popplerTextSpan' + let result' = (/= 0) result + touchManagedPtr popplerTextSpan + return result' + +#if ENABLE_OVERLOADING +data TextSpanIsSerifFontMethodInfo +instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo TextSpanIsSerifFontMethodInfo TextSpan signature where + overloadedMethod _ = textSpanIsSerifFont + +#endif + +#if ENABLE_OVERLOADING +type family ResolveTextSpanMethod (t :: Symbol) (o :: *) :: * where + ResolveTextSpanMethod "copy" o = TextSpanCopyMethodInfo + ResolveTextSpanMethod "free" o = TextSpanFreeMethodInfo + ResolveTextSpanMethod "isBoldFont" o = TextSpanIsBoldFontMethodInfo + ResolveTextSpanMethod "isFixedWidthFont" o = TextSpanIsFixedWidthFontMethodInfo + ResolveTextSpanMethod "isSerifFont" o = TextSpanIsSerifFontMethodInfo + ResolveTextSpanMethod "getColor" o = TextSpanGetColorMethodInfo + ResolveTextSpanMethod "getFontName" o = TextSpanGetFontNameMethodInfo + ResolveTextSpanMethod "getText" o = TextSpanGetTextMethodInfo + ResolveTextSpanMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveTextSpanMethod t TextSpan, O.MethodInfo info TextSpan p) => OL.IsLabel t (TextSpan -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + 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,50 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Poppler.Structs.TextSpan where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype TextSpan = TextSpan (ManagedPtr TextSpan) +instance BoxedObject TextSpan where +#if ENABLE_OVERLOADING +data TextSpanCopyMethodInfo +#endif +#if ENABLE_OVERLOADING +data TextSpanFreeMethodInfo +#endif +#if ENABLE_OVERLOADING +data TextSpanGetColorMethodInfo +#endif +#if ENABLE_OVERLOADING +data TextSpanGetFontNameMethodInfo +#endif +#if ENABLE_OVERLOADING +data TextSpanGetTextMethodInfo +#endif +#if ENABLE_OVERLOADING +data TextSpanIsBoldFontMethodInfo +#endif +#if ENABLE_OVERLOADING +data TextSpanIsFixedWidthFontMethodInfo +#endif +#if ENABLE_OVERLOADING +data TextSpanIsSerifFontMethodInfo +#endif 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,41 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Poppler.Unions + ( module GI.Poppler.Unions.Action , + + + ) where + +import GI.Poppler.Unions.Action + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + + + 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,680 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) + +A data structure for holding actions +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.Poppler.Unions.Action + ( + +-- * Exported types + Action(..) , + newZeroAction , + noAction , + + + -- * Methods +-- ** copy #method:copy# + +#if ENABLE_OVERLOADING + ActionCopyMethodInfo , +#endif + actionCopy , + + +-- ** free #method:free# + +#if ENABLE_OVERLOADING + ActionFreeMethodInfo , +#endif + actionFree , + + + + + -- * Properties +-- ** any #attr:any# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + action_any , +#endif + getActionAny , + + +-- ** gotoDest #attr:gotoDest# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + action_gotoDest , +#endif + getActionGotoDest , + + +-- ** gotoRemote #attr:gotoRemote# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + action_gotoRemote , +#endif + getActionGotoRemote , + + +-- ** javascript #attr:javascript# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + action_javascript , +#endif + getActionJavascript , + + +-- ** launch #attr:launch# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + action_launch , +#endif + getActionLaunch , + + +-- ** movie #attr:movie# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + action_movie , +#endif + getActionMovie , + + +-- ** named #attr:named# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + action_named , +#endif + getActionNamed , + + +-- ** ocgState #attr:ocgState# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + action_ocgState , +#endif + getActionOcgState , + + +-- ** rendition #attr:rendition# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + action_rendition , +#endif + getActionRendition , + + +-- ** type #attr:type# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + action_type , +#endif + getActionType , + setActionType , + + +-- ** uri #attr:uri# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + action_uri , +#endif + getActionUri , + + + + + ) where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +import {-# SOURCE #-} qualified GI.Poppler.Enums as Poppler.Enums +import {-# SOURCE #-} qualified GI.Poppler.Structs.ActionAny as Poppler.ActionAny +import {-# SOURCE #-} qualified GI.Poppler.Structs.ActionGotoDest as Poppler.ActionGotoDest +import {-# SOURCE #-} qualified GI.Poppler.Structs.ActionGotoRemote as Poppler.ActionGotoRemote +import {-# SOURCE #-} qualified GI.Poppler.Structs.ActionJavascript as Poppler.ActionJavascript +import {-# SOURCE #-} qualified GI.Poppler.Structs.ActionLaunch as Poppler.ActionLaunch +import {-# SOURCE #-} qualified GI.Poppler.Structs.ActionMovie as Poppler.ActionMovie +import {-# SOURCE #-} qualified GI.Poppler.Structs.ActionNamed as Poppler.ActionNamed +import {-# SOURCE #-} qualified GI.Poppler.Structs.ActionOCGState as Poppler.ActionOCGState +import {-# SOURCE #-} qualified GI.Poppler.Structs.ActionRendition as Poppler.ActionRendition +import {-# SOURCE #-} qualified GI.Poppler.Structs.ActionUri as Poppler.ActionUri + +-- | Memory-managed wrapper type. +newtype Action = Action (ManagedPtr 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 + +-- | Construct a `Action` struct initialized to zero. +newZeroAction :: MonadIO m => m Action +newZeroAction = liftIO $ callocBoxedBytes 32 >>= wrapBoxed Action + +instance tag ~ 'AttrSet => Constructible Action tag where + new _ attrs = do + o <- newZeroAction + GI.Attributes.set o attrs + return o + + +-- | A convenience alias for `Nothing` :: `Maybe` `Action`. +noAction :: Maybe Action +noAction = Nothing + +{- | +Get the value of the “@type@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' action #type +@ +-} +getActionType :: MonadIO m => Action -> m Poppler.Enums.ActionType +getActionType s = liftIO $ withManagedPtr s $ \ptr -> do + val <- peek (ptr `plusPtr` 0) :: IO CUInt + let val' = (toEnum . fromIntegral) val + return val' + +{- | +Set the value of the “@type@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.set' action [ #type 'Data.GI.Base.Attributes.:=' value ] +@ +-} +setActionType :: MonadIO m => Action -> Poppler.Enums.ActionType -> m () +setActionType s val = liftIO $ withManagedPtr s $ \ptr -> do + let val' = (fromIntegral . fromEnum) val + poke (ptr `plusPtr` 0) (val' :: CUInt) + +#if ENABLE_OVERLOADING +data ActionTypeFieldInfo +instance AttrInfo ActionTypeFieldInfo where + type AttrAllowedOps ActionTypeFieldInfo = '[ 'AttrSet, 'AttrGet] + type AttrSetTypeConstraint ActionTypeFieldInfo = (~) Poppler.Enums.ActionType + type AttrBaseTypeConstraint ActionTypeFieldInfo = (~) Action + type AttrGetType ActionTypeFieldInfo = Poppler.Enums.ActionType + type AttrLabel ActionTypeFieldInfo = "type" + type AttrOrigin ActionTypeFieldInfo = Action + attrGet _ = getActionType + attrSet _ = setActionType + attrConstruct = undefined + attrClear _ = undefined + +action_type :: AttrLabelProxy "type" +action_type = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@any@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' action #any +@ +-} +getActionAny :: MonadIO m => Action -> m Poppler.ActionAny.ActionAny +getActionAny s = liftIO $ withManagedPtr s $ \ptr -> do + let val = ptr `plusPtr` 0 :: (Ptr Poppler.ActionAny.ActionAny) + val' <- (newPtr Poppler.ActionAny.ActionAny) val + return val' + +#if ENABLE_OVERLOADING +data ActionAnyFieldInfo +instance AttrInfo ActionAnyFieldInfo where + type AttrAllowedOps ActionAnyFieldInfo = '[ 'AttrGet] + type AttrSetTypeConstraint ActionAnyFieldInfo = (~) (Ptr Poppler.ActionAny.ActionAny) + type AttrBaseTypeConstraint ActionAnyFieldInfo = (~) Action + type AttrGetType ActionAnyFieldInfo = Poppler.ActionAny.ActionAny + type AttrLabel ActionAnyFieldInfo = "any" + type AttrOrigin ActionAnyFieldInfo = Action + attrGet _ = getActionAny + attrSet _ = undefined + attrConstruct = undefined + attrClear _ = undefined + +action_any :: AttrLabelProxy "any" +action_any = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@goto_dest@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' action #gotoDest +@ +-} +getActionGotoDest :: MonadIO m => Action -> m Poppler.ActionGotoDest.ActionGotoDest +getActionGotoDest s = liftIO $ withManagedPtr s $ \ptr -> do + let val = ptr `plusPtr` 0 :: (Ptr Poppler.ActionGotoDest.ActionGotoDest) + val' <- (newPtr Poppler.ActionGotoDest.ActionGotoDest) val + return val' + +#if ENABLE_OVERLOADING +data ActionGotoDestFieldInfo +instance AttrInfo ActionGotoDestFieldInfo where + type AttrAllowedOps ActionGotoDestFieldInfo = '[ 'AttrGet] + type AttrSetTypeConstraint ActionGotoDestFieldInfo = (~) (Ptr Poppler.ActionGotoDest.ActionGotoDest) + type AttrBaseTypeConstraint ActionGotoDestFieldInfo = (~) Action + type AttrGetType ActionGotoDestFieldInfo = Poppler.ActionGotoDest.ActionGotoDest + type AttrLabel ActionGotoDestFieldInfo = "goto_dest" + type AttrOrigin ActionGotoDestFieldInfo = Action + attrGet _ = getActionGotoDest + attrSet _ = undefined + attrConstruct = undefined + attrClear _ = undefined + +action_gotoDest :: AttrLabelProxy "gotoDest" +action_gotoDest = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@goto_remote@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' action #gotoRemote +@ +-} +getActionGotoRemote :: MonadIO m => Action -> m Poppler.ActionGotoRemote.ActionGotoRemote +getActionGotoRemote s = liftIO $ withManagedPtr s $ \ptr -> do + let val = ptr `plusPtr` 0 :: (Ptr Poppler.ActionGotoRemote.ActionGotoRemote) + val' <- (newPtr Poppler.ActionGotoRemote.ActionGotoRemote) val + return val' + +#if ENABLE_OVERLOADING +data ActionGotoRemoteFieldInfo +instance AttrInfo ActionGotoRemoteFieldInfo where + type AttrAllowedOps ActionGotoRemoteFieldInfo = '[ 'AttrGet] + type AttrSetTypeConstraint ActionGotoRemoteFieldInfo = (~) (Ptr Poppler.ActionGotoRemote.ActionGotoRemote) + type AttrBaseTypeConstraint ActionGotoRemoteFieldInfo = (~) Action + type AttrGetType ActionGotoRemoteFieldInfo = Poppler.ActionGotoRemote.ActionGotoRemote + type AttrLabel ActionGotoRemoteFieldInfo = "goto_remote" + type AttrOrigin ActionGotoRemoteFieldInfo = Action + attrGet _ = getActionGotoRemote + attrSet _ = undefined + attrConstruct = undefined + attrClear _ = undefined + +action_gotoRemote :: AttrLabelProxy "gotoRemote" +action_gotoRemote = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@launch@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' action #launch +@ +-} +getActionLaunch :: MonadIO m => Action -> m Poppler.ActionLaunch.ActionLaunch +getActionLaunch s = liftIO $ withManagedPtr s $ \ptr -> do + let val = ptr `plusPtr` 0 :: (Ptr Poppler.ActionLaunch.ActionLaunch) + val' <- (newPtr Poppler.ActionLaunch.ActionLaunch) val + return val' + +#if ENABLE_OVERLOADING +data ActionLaunchFieldInfo +instance AttrInfo ActionLaunchFieldInfo where + type AttrAllowedOps ActionLaunchFieldInfo = '[ 'AttrGet] + type AttrSetTypeConstraint ActionLaunchFieldInfo = (~) (Ptr Poppler.ActionLaunch.ActionLaunch) + type AttrBaseTypeConstraint ActionLaunchFieldInfo = (~) Action + type AttrGetType ActionLaunchFieldInfo = Poppler.ActionLaunch.ActionLaunch + type AttrLabel ActionLaunchFieldInfo = "launch" + type AttrOrigin ActionLaunchFieldInfo = Action + attrGet _ = getActionLaunch + attrSet _ = undefined + attrConstruct = undefined + attrClear _ = undefined + +action_launch :: AttrLabelProxy "launch" +action_launch = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@uri@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' action #uri +@ +-} +getActionUri :: MonadIO m => Action -> m Poppler.ActionUri.ActionUri +getActionUri s = liftIO $ withManagedPtr s $ \ptr -> do + let val = ptr `plusPtr` 0 :: (Ptr Poppler.ActionUri.ActionUri) + val' <- (newPtr Poppler.ActionUri.ActionUri) val + return val' + +#if ENABLE_OVERLOADING +data ActionUriFieldInfo +instance AttrInfo ActionUriFieldInfo where + type AttrAllowedOps ActionUriFieldInfo = '[ 'AttrGet] + type AttrSetTypeConstraint ActionUriFieldInfo = (~) (Ptr Poppler.ActionUri.ActionUri) + type AttrBaseTypeConstraint ActionUriFieldInfo = (~) Action + type AttrGetType ActionUriFieldInfo = Poppler.ActionUri.ActionUri + type AttrLabel ActionUriFieldInfo = "uri" + type AttrOrigin ActionUriFieldInfo = Action + attrGet _ = getActionUri + attrSet _ = undefined + attrConstruct = undefined + attrClear _ = undefined + +action_uri :: AttrLabelProxy "uri" +action_uri = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@named@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' action #named +@ +-} +getActionNamed :: MonadIO m => Action -> m Poppler.ActionNamed.ActionNamed +getActionNamed s = liftIO $ withManagedPtr s $ \ptr -> do + let val = ptr `plusPtr` 0 :: (Ptr Poppler.ActionNamed.ActionNamed) + val' <- (newPtr Poppler.ActionNamed.ActionNamed) val + return val' + +#if ENABLE_OVERLOADING +data ActionNamedFieldInfo +instance AttrInfo ActionNamedFieldInfo where + type AttrAllowedOps ActionNamedFieldInfo = '[ 'AttrGet] + type AttrSetTypeConstraint ActionNamedFieldInfo = (~) (Ptr Poppler.ActionNamed.ActionNamed) + type AttrBaseTypeConstraint ActionNamedFieldInfo = (~) Action + type AttrGetType ActionNamedFieldInfo = Poppler.ActionNamed.ActionNamed + type AttrLabel ActionNamedFieldInfo = "named" + type AttrOrigin ActionNamedFieldInfo = Action + attrGet _ = getActionNamed + attrSet _ = undefined + attrConstruct = undefined + attrClear _ = undefined + +action_named :: AttrLabelProxy "named" +action_named = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@movie@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' action #movie +@ +-} +getActionMovie :: MonadIO m => Action -> m Poppler.ActionMovie.ActionMovie +getActionMovie s = liftIO $ withManagedPtr s $ \ptr -> do + let val = ptr `plusPtr` 0 :: (Ptr Poppler.ActionMovie.ActionMovie) + val' <- (newPtr Poppler.ActionMovie.ActionMovie) val + return val' + +#if ENABLE_OVERLOADING +data ActionMovieFieldInfo +instance AttrInfo ActionMovieFieldInfo where + type AttrAllowedOps ActionMovieFieldInfo = '[ 'AttrGet] + type AttrSetTypeConstraint ActionMovieFieldInfo = (~) (Ptr Poppler.ActionMovie.ActionMovie) + type AttrBaseTypeConstraint ActionMovieFieldInfo = (~) Action + type AttrGetType ActionMovieFieldInfo = Poppler.ActionMovie.ActionMovie + type AttrLabel ActionMovieFieldInfo = "movie" + type AttrOrigin ActionMovieFieldInfo = Action + attrGet _ = getActionMovie + attrSet _ = undefined + attrConstruct = undefined + attrClear _ = undefined + +action_movie :: AttrLabelProxy "movie" +action_movie = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@rendition@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' action #rendition +@ +-} +getActionRendition :: MonadIO m => Action -> m Poppler.ActionRendition.ActionRendition +getActionRendition s = liftIO $ withManagedPtr s $ \ptr -> do + let val = ptr `plusPtr` 0 :: (Ptr Poppler.ActionRendition.ActionRendition) + val' <- (newPtr Poppler.ActionRendition.ActionRendition) val + return val' + +#if ENABLE_OVERLOADING +data ActionRenditionFieldInfo +instance AttrInfo ActionRenditionFieldInfo where + type AttrAllowedOps ActionRenditionFieldInfo = '[ 'AttrGet] + type AttrSetTypeConstraint ActionRenditionFieldInfo = (~) (Ptr Poppler.ActionRendition.ActionRendition) + type AttrBaseTypeConstraint ActionRenditionFieldInfo = (~) Action + type AttrGetType ActionRenditionFieldInfo = Poppler.ActionRendition.ActionRendition + type AttrLabel ActionRenditionFieldInfo = "rendition" + type AttrOrigin ActionRenditionFieldInfo = Action + attrGet _ = getActionRendition + attrSet _ = undefined + attrConstruct = undefined + attrClear _ = undefined + +action_rendition :: AttrLabelProxy "rendition" +action_rendition = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@ocg_state@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' action #ocgState +@ +-} +getActionOcgState :: MonadIO m => Action -> m Poppler.ActionOCGState.ActionOCGState +getActionOcgState s = liftIO $ withManagedPtr s $ \ptr -> do + let val = ptr `plusPtr` 0 :: (Ptr Poppler.ActionOCGState.ActionOCGState) + val' <- (newPtr Poppler.ActionOCGState.ActionOCGState) val + return val' + +#if ENABLE_OVERLOADING +data ActionOcgStateFieldInfo +instance AttrInfo ActionOcgStateFieldInfo where + type AttrAllowedOps ActionOcgStateFieldInfo = '[ 'AttrGet] + type AttrSetTypeConstraint ActionOcgStateFieldInfo = (~) (Ptr Poppler.ActionOCGState.ActionOCGState) + type AttrBaseTypeConstraint ActionOcgStateFieldInfo = (~) Action + type AttrGetType ActionOcgStateFieldInfo = Poppler.ActionOCGState.ActionOCGState + type AttrLabel ActionOcgStateFieldInfo = "ocg_state" + type AttrOrigin ActionOcgStateFieldInfo = Action + attrGet _ = getActionOcgState + attrSet _ = undefined + attrConstruct = undefined + attrClear _ = undefined + +action_ocgState :: AttrLabelProxy "ocgState" +action_ocgState = AttrLabelProxy + +#endif + + +{- | +Get the value of the “@javascript@” field. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' action #javascript +@ +-} +getActionJavascript :: MonadIO m => Action -> m Poppler.ActionJavascript.ActionJavascript +getActionJavascript s = liftIO $ withManagedPtr s $ \ptr -> do + let val = ptr `plusPtr` 0 :: (Ptr Poppler.ActionJavascript.ActionJavascript) + val' <- (newPtr Poppler.ActionJavascript.ActionJavascript) val + return val' + +#if ENABLE_OVERLOADING +data ActionJavascriptFieldInfo +instance AttrInfo ActionJavascriptFieldInfo where + type AttrAllowedOps ActionJavascriptFieldInfo = '[ 'AttrGet] + type AttrSetTypeConstraint ActionJavascriptFieldInfo = (~) (Ptr Poppler.ActionJavascript.ActionJavascript) + type AttrBaseTypeConstraint ActionJavascriptFieldInfo = (~) Action + type AttrGetType ActionJavascriptFieldInfo = Poppler.ActionJavascript.ActionJavascript + type AttrLabel ActionJavascriptFieldInfo = "javascript" + type AttrOrigin ActionJavascriptFieldInfo = Action + attrGet _ = getActionJavascript + attrSet _ = undefined + attrConstruct = undefined + attrClear _ = undefined + +action_javascript :: AttrLabelProxy "javascript" +action_javascript = AttrLabelProxy + +#endif + + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList Action +type instance O.AttributeList Action = ActionAttributeList +type ActionAttributeList = ('[ '("type", ActionTypeFieldInfo), '("any", ActionAnyFieldInfo), '("gotoDest", ActionGotoDestFieldInfo), '("gotoRemote", ActionGotoRemoteFieldInfo), '("launch", ActionLaunchFieldInfo), '("uri", ActionUriFieldInfo), '("named", ActionNamedFieldInfo), '("movie", ActionMovieFieldInfo), '("rendition", ActionRenditionFieldInfo), '("ocgState", ActionOcgStateFieldInfo), '("javascript", ActionJavascriptFieldInfo)] :: [(Symbol, *)]) +#endif + +-- method Action::copy +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "action", argType = TInterface (Name {namespace = "Poppler", name = "Action"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerAction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Poppler", name = "Action"})) +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_action_copy" poppler_action_copy :: + Ptr Action -> -- action : TInterface (Name {namespace = "Poppler", name = "Action"}) + IO (Ptr Action) + +{- | +Copies /@action@/, creating an identical 'GI.Poppler.Unions.Action.Action'. +-} +actionCopy :: + (B.CallStack.HasCallStack, MonadIO m) => + Action + {- ^ /@action@/: a 'GI.Poppler.Unions.Action.Action' -} + -> m Action + {- ^ __Returns:__ a new action identical to /@action@/ -} +actionCopy action = liftIO $ do + action' <- unsafeManagedPtrGetPtr action + result <- poppler_action_copy action' + checkUnexpectedReturnNULL "actionCopy" result + result' <- (wrapBoxed Action) result + touchManagedPtr action + return result' + +#if ENABLE_OVERLOADING +data ActionCopyMethodInfo +instance (signature ~ (m Action), MonadIO m) => O.MethodInfo ActionCopyMethodInfo Action signature where + overloadedMethod _ = actionCopy + +#endif + +-- method Action::free +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "action", argType = TInterface (Name {namespace = "Poppler", name = "Action"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PopplerAction", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "poppler_action_free" poppler_action_free :: + Ptr Action -> -- action : TInterface (Name {namespace = "Poppler", name = "Action"}) + IO () + +{- | +Frees /@action@/ +-} +actionFree :: + (B.CallStack.HasCallStack, MonadIO m) => + Action + {- ^ /@action@/: a 'GI.Poppler.Unions.Action.Action' -} + -> m () +actionFree action = liftIO $ do + action' <- unsafeManagedPtrGetPtr action + poppler_action_free action' + touchManagedPtr action + return () + +#if ENABLE_OVERLOADING +data ActionFreeMethodInfo +instance (signature ~ (m ()), MonadIO m) => O.MethodInfo ActionFreeMethodInfo Action signature where + overloadedMethod _ = actionFree + +#endif + +#if ENABLE_OVERLOADING +type family ResolveActionMethod (t :: Symbol) (o :: *) :: * where + ResolveActionMethod "copy" o = ActionCopyMethodInfo + ResolveActionMethod "free" o = ActionFreeMethodInfo + ResolveActionMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveActionMethod t Action, O.MethodInfo info Action p) => OL.IsLabel t (Action -> p) where +#if MIN_VERSION_base(4,10,0) + fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#else + fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) +#endif + +#endif + + 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,32 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.Poppler.Unions.Action where + +import Data.GI.Base.ShortPrelude +import qualified Data.GI.Base.ShortPrelude as SP +import qualified Data.GI.Base.Overloading as O +import qualified Prelude as P + +import qualified Data.GI.Base.Attributes as GI.Attributes +import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr +import qualified Data.GI.Base.GClosure as B.GClosure +import qualified Data.GI.Base.GError as B.GError +import qualified Data.GI.Base.GVariant as B.GVariant +import qualified Data.GI.Base.GValue as B.GValue +import qualified Data.GI.Base.GParamSpec as B.GParamSpec +import qualified Data.GI.Base.CallStack as B.CallStack +import qualified Data.GI.Base.Properties as B.Properties +import qualified Data.Text as T +import qualified Data.ByteString.Char8 as B +import qualified Data.Map as Map +import qualified Foreign.Ptr as FP +import qualified GHC.OverloadedLabels as OL + +newtype Action = Action (ManagedPtr Action) +instance BoxedObject Action where +#if ENABLE_OVERLOADING +data ActionCopyMethodInfo +#endif +#if ENABLE_OVERLOADING +data ActionFreeMethodInfo +#endif diff --git a/LICENSE b/LICENSE --- a/LICENSE +++ b/LICENSE @@ -1,3 +1,17 @@ +The gi-poppler library and included works are provided under the terms of the +GNU Library General Public License (LGPL) version 2.1 with the following +exception: + +Static linking of applications or any other source to the gi-poppler library +does not constitute a modified or derivative work and does not require +the author(s) to provide source code for said work, to link against the +shared gi-poppler libraries, or to link their applications against a +user-supplied version of gi-poppler. If you link applications to a modified +version of gi-poppler, then the changes to gi-poppler must be provided under the +terms of the LGPL. + +---------------------------------------------------------------------------- + GNU LESSER GENERAL PUBLIC LICENSE Version 2.1, February 1999 diff --git a/README.md b/README.md --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@ # Documentation Autogenerated documentation for this package can be found at -[https://hackage.haskell.org/package/gi-poppler-0.18.15/docs/GI-Poppler.html](https://hackage.haskell.org/package/gi-poppler-0.18.15/docs/GI-Poppler.html) +[https://hackage.haskell.org/package/gi-poppler-0.18.17/docs/GI-Poppler.html](https://hackage.haskell.org/package/gi-poppler-0.18.17/docs/GI-Poppler.html) For general documentation on using [haskell-gi](https://github.com/haskell-gi/haskell-gi) based bindings, see [the project page](https://github.com/haskell-gi/haskell-gi) or [the Wiki](https://github.com/haskell-gi/haskell-gi/wiki). diff --git a/gi-poppler.cabal b/gi-poppler.cabal --- a/gi-poppler.cabal +++ b/gi-poppler.cabal @@ -1,33 +1,33 @@ name: gi-poppler -version: 0.18.15 +version: 0.18.17 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) +maintainer: Iñaki García Etxebarria (inaki@blueleaf.cc) category: Bindings build-type: Custom -cabal-version: >= 1.24 +cabal-version: 1.24 extra-source-files: README.md ChangeLog.md stack.yaml Poppler.overrides custom-setup - setup-depends: base >= 4.7 && < 5, + setup-depends: base >= 4.9 && < 5, Cabal >= 1.24, - haskell-gi == 0.21.* + haskell-gi >= 0.21.0 && < 0.23 library default-language: Haskell2010 - default-extensions: NoImplicitPrelude, ScopedTypeVariables, CPP, OverloadedStrings, NegativeLiterals, ConstraintKinds, TypeFamilies, MultiParamTypeClasses, KindSignatures, FlexibleInstances, UndecidableInstances, DataKinds, FlexibleContexts + default-extensions: NoImplicitPrelude, ScopedTypeVariables, CPP, OverloadedStrings, NegativeLiterals, ConstraintKinds, TypeFamilies, MultiParamTypeClasses, KindSignatures, FlexibleInstances, UndecidableInstances, DataKinds, FlexibleContexts, UndecidableSuperClasses other-extensions: PatternSynonyms, ViewPatterns ghc-options: -fno-warn-unused-imports -fno-warn-warnings-deprecations pkgconfig-depends: poppler-glib >= 0.18 && < 1 build-depends: base >= 4.7 && <5, - haskell-gi-base == 0.21.*, - haskell-gi == 0.21.*, + haskell-gi-base >= 0.21.0 && < 0.23, + haskell-gi >= 0.21.0 && < 0.23, haskell-gi-overloading < 1.1, gi-cairo == 1.0.*, gi-gio == 2.0.*, @@ -42,3 +42,63 @@ -- see https://ghc.haskell.org/trac/ghc/ticket/14382 if impl(ghc == 8.2.*) build-depends: haskell-gi-overloading == 0.0 + + exposed-modules: 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 diff --git a/stack.yaml b/stack.yaml --- a/stack.yaml +++ b/stack.yaml @@ -1,3 +1,3 @@ packages: - '.' -resolver: lts-9.21 +resolver: lts-13.7