-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

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(..)                  ,


-- ** PrintDuplex #enum:PrintDuplex#

    PrintDuplex(..)                         ,


-- ** 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.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
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.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
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 GHC.Records as R


-- 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 (Int -> StructureWritingMode -> ShowS
[StructureWritingMode] -> ShowS
StructureWritingMode -> String
(Int -> StructureWritingMode -> ShowS)
-> (StructureWritingMode -> String)
-> ([StructureWritingMode] -> ShowS)
-> Show StructureWritingMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StructureWritingMode] -> ShowS
$cshowList :: [StructureWritingMode] -> ShowS
show :: StructureWritingMode -> String
$cshow :: StructureWritingMode -> String
showsPrec :: Int -> StructureWritingMode -> ShowS
$cshowsPrec :: Int -> StructureWritingMode -> ShowS
Show, StructureWritingMode -> StructureWritingMode -> Bool
(StructureWritingMode -> StructureWritingMode -> Bool)
-> (StructureWritingMode -> StructureWritingMode -> Bool)
-> Eq StructureWritingMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StructureWritingMode -> StructureWritingMode -> Bool
$c/= :: StructureWritingMode -> StructureWritingMode -> Bool
== :: StructureWritingMode -> StructureWritingMode -> Bool
$c== :: StructureWritingMode -> StructureWritingMode -> Bool
Eq)

instance P.Enum StructureWritingMode where
    fromEnum :: StructureWritingMode -> Int
fromEnum StructureWritingMode
StructureWritingModeLrTb = Int
0
    fromEnum StructureWritingMode
StructureWritingModeRlTb = Int
1
    fromEnum StructureWritingMode
StructureWritingModeTbRl = Int
2
    fromEnum (AnotherStructureWritingMode Int
k) = Int
k

    toEnum :: Int -> StructureWritingMode
toEnum Int
0 = StructureWritingMode
StructureWritingModeLrTb
    toEnum Int
1 = StructureWritingMode
StructureWritingModeRlTb
    toEnum Int
2 = StructureWritingMode
StructureWritingModeTbRl
    toEnum Int
k = Int -> StructureWritingMode
AnotherStructureWritingMode Int
k

instance P.Ord StructureWritingMode where
    compare :: StructureWritingMode -> StructureWritingMode -> Ordering
compare StructureWritingMode
a StructureWritingMode
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (StructureWritingMode -> Int
forall a. Enum a => a -> Int
P.fromEnum StructureWritingMode
a) (StructureWritingMode -> Int
forall a. Enum a => a -> Int
P.fromEnum StructureWritingMode
b)

type instance O.ParentTypes StructureWritingMode = '[]
instance O.HasParentTypes StructureWritingMode

foreign import ccall "poppler_structure_writing_mode_get_type" c_poppler_structure_writing_mode_get_type :: 
    IO GType

instance B.Types.TypedObject StructureWritingMode where
    glibType :: IO GType
glibType = IO GType
c_poppler_structure_writing_mode_get_type

instance B.Types.BoxedEnum StructureWritingMode

-- 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 (Int -> StructureTextDecoration -> ShowS
[StructureTextDecoration] -> ShowS
StructureTextDecoration -> String
(Int -> StructureTextDecoration -> ShowS)
-> (StructureTextDecoration -> String)
-> ([StructureTextDecoration] -> ShowS)
-> Show StructureTextDecoration
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StructureTextDecoration] -> ShowS
$cshowList :: [StructureTextDecoration] -> ShowS
show :: StructureTextDecoration -> String
$cshow :: StructureTextDecoration -> String
showsPrec :: Int -> StructureTextDecoration -> ShowS
$cshowsPrec :: Int -> StructureTextDecoration -> ShowS
Show, StructureTextDecoration -> StructureTextDecoration -> Bool
(StructureTextDecoration -> StructureTextDecoration -> Bool)
-> (StructureTextDecoration -> StructureTextDecoration -> Bool)
-> Eq StructureTextDecoration
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StructureTextDecoration -> StructureTextDecoration -> Bool
$c/= :: StructureTextDecoration -> StructureTextDecoration -> Bool
== :: StructureTextDecoration -> StructureTextDecoration -> Bool
$c== :: StructureTextDecoration -> StructureTextDecoration -> Bool
Eq)

instance P.Enum StructureTextDecoration where
    fromEnum :: StructureTextDecoration -> Int
fromEnum StructureTextDecoration
StructureTextDecorationNone = Int
0
    fromEnum StructureTextDecoration
StructureTextDecorationUnderline = Int
1
    fromEnum StructureTextDecoration
StructureTextDecorationOverline = Int
2
    fromEnum StructureTextDecoration
StructureTextDecorationLinethrough = Int
3
    fromEnum (AnotherStructureTextDecoration Int
k) = Int
k

    toEnum :: Int -> StructureTextDecoration
toEnum Int
0 = StructureTextDecoration
StructureTextDecorationNone
    toEnum Int
1 = StructureTextDecoration
StructureTextDecorationUnderline
    toEnum Int
2 = StructureTextDecoration
StructureTextDecorationOverline
    toEnum Int
3 = StructureTextDecoration
StructureTextDecorationLinethrough
    toEnum Int
k = Int -> StructureTextDecoration
AnotherStructureTextDecoration Int
k

instance P.Ord StructureTextDecoration where
    compare :: StructureTextDecoration -> StructureTextDecoration -> Ordering
compare StructureTextDecoration
a StructureTextDecoration
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (StructureTextDecoration -> Int
forall a. Enum a => a -> Int
P.fromEnum StructureTextDecoration
a) (StructureTextDecoration -> Int
forall a. Enum a => a -> Int
P.fromEnum StructureTextDecoration
b)

type instance O.ParentTypes StructureTextDecoration = '[]
instance O.HasParentTypes StructureTextDecoration

foreign import ccall "poppler_structure_text_decoration_get_type" c_poppler_structure_text_decoration_get_type :: 
    IO GType

instance B.Types.TypedObject StructureTextDecoration where
    glibType :: IO GType
glibType = IO GType
c_poppler_structure_text_decoration_get_type

instance B.Types.BoxedEnum StructureTextDecoration

-- 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 (Int -> StructureTextAlign -> ShowS
[StructureTextAlign] -> ShowS
StructureTextAlign -> String
(Int -> StructureTextAlign -> ShowS)
-> (StructureTextAlign -> String)
-> ([StructureTextAlign] -> ShowS)
-> Show StructureTextAlign
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StructureTextAlign] -> ShowS
$cshowList :: [StructureTextAlign] -> ShowS
show :: StructureTextAlign -> String
$cshow :: StructureTextAlign -> String
showsPrec :: Int -> StructureTextAlign -> ShowS
$cshowsPrec :: Int -> StructureTextAlign -> ShowS
Show, StructureTextAlign -> StructureTextAlign -> Bool
(StructureTextAlign -> StructureTextAlign -> Bool)
-> (StructureTextAlign -> StructureTextAlign -> Bool)
-> Eq StructureTextAlign
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StructureTextAlign -> StructureTextAlign -> Bool
$c/= :: StructureTextAlign -> StructureTextAlign -> Bool
== :: StructureTextAlign -> StructureTextAlign -> Bool
$c== :: StructureTextAlign -> StructureTextAlign -> Bool
Eq)

instance P.Enum StructureTextAlign where
    fromEnum :: StructureTextAlign -> Int
fromEnum StructureTextAlign
StructureTextAlignStart = Int
0
    fromEnum StructureTextAlign
StructureTextAlignCenter = Int
1
    fromEnum StructureTextAlign
StructureTextAlignEnd = Int
2
    fromEnum StructureTextAlign
StructureTextAlignJustify = Int
3
    fromEnum (AnotherStructureTextAlign Int
k) = Int
k

    toEnum :: Int -> StructureTextAlign
toEnum Int
0 = StructureTextAlign
StructureTextAlignStart
    toEnum Int
1 = StructureTextAlign
StructureTextAlignCenter
    toEnum Int
2 = StructureTextAlign
StructureTextAlignEnd
    toEnum Int
3 = StructureTextAlign
StructureTextAlignJustify
    toEnum Int
k = Int -> StructureTextAlign
AnotherStructureTextAlign Int
k

instance P.Ord StructureTextAlign where
    compare :: StructureTextAlign -> StructureTextAlign -> Ordering
compare StructureTextAlign
a StructureTextAlign
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (StructureTextAlign -> Int
forall a. Enum a => a -> Int
P.fromEnum StructureTextAlign
a) (StructureTextAlign -> Int
forall a. Enum a => a -> Int
P.fromEnum StructureTextAlign
b)

type instance O.ParentTypes StructureTextAlign = '[]
instance O.HasParentTypes StructureTextAlign

foreign import ccall "poppler_structure_text_align_get_type" c_poppler_structure_text_align_get_type :: 
    IO GType

instance B.Types.TypedObject StructureTextAlign where
    glibType :: IO GType
glibType = IO GType
c_poppler_structure_text_align_get_type

instance B.Types.BoxedEnum StructureTextAlign

-- 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 (Int -> StructureTableScope -> ShowS
[StructureTableScope] -> ShowS
StructureTableScope -> String
(Int -> StructureTableScope -> ShowS)
-> (StructureTableScope -> String)
-> ([StructureTableScope] -> ShowS)
-> Show StructureTableScope
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StructureTableScope] -> ShowS
$cshowList :: [StructureTableScope] -> ShowS
show :: StructureTableScope -> String
$cshow :: StructureTableScope -> String
showsPrec :: Int -> StructureTableScope -> ShowS
$cshowsPrec :: Int -> StructureTableScope -> ShowS
Show, StructureTableScope -> StructureTableScope -> Bool
(StructureTableScope -> StructureTableScope -> Bool)
-> (StructureTableScope -> StructureTableScope -> Bool)
-> Eq StructureTableScope
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StructureTableScope -> StructureTableScope -> Bool
$c/= :: StructureTableScope -> StructureTableScope -> Bool
== :: StructureTableScope -> StructureTableScope -> Bool
$c== :: StructureTableScope -> StructureTableScope -> Bool
Eq)

instance P.Enum StructureTableScope where
    fromEnum :: StructureTableScope -> Int
fromEnum StructureTableScope
StructureTableScopeRow = Int
0
    fromEnum StructureTableScope
StructureTableScopeColumn = Int
1
    fromEnum StructureTableScope
StructureTableScopeBoth = Int
2
    fromEnum (AnotherStructureTableScope Int
k) = Int
k

    toEnum :: Int -> StructureTableScope
toEnum Int
0 = StructureTableScope
StructureTableScopeRow
    toEnum Int
1 = StructureTableScope
StructureTableScopeColumn
    toEnum Int
2 = StructureTableScope
StructureTableScopeBoth
    toEnum Int
k = Int -> StructureTableScope
AnotherStructureTableScope Int
k

instance P.Ord StructureTableScope where
    compare :: StructureTableScope -> StructureTableScope -> Ordering
compare StructureTableScope
a StructureTableScope
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (StructureTableScope -> Int
forall a. Enum a => a -> Int
P.fromEnum StructureTableScope
a) (StructureTableScope -> Int
forall a. Enum a => a -> Int
P.fromEnum StructureTableScope
b)

type instance O.ParentTypes StructureTableScope = '[]
instance O.HasParentTypes StructureTableScope

foreign import ccall "poppler_structure_table_scope_get_type" c_poppler_structure_table_scope_get_type :: 
    IO GType

instance B.Types.TypedObject StructureTableScope where
    glibType :: IO GType
glibType = IO GType
c_poppler_structure_table_scope_get_type

instance B.Types.BoxedEnum StructureTableScope

-- 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 (Int -> StructureRubyPosition -> ShowS
[StructureRubyPosition] -> ShowS
StructureRubyPosition -> String
(Int -> StructureRubyPosition -> ShowS)
-> (StructureRubyPosition -> String)
-> ([StructureRubyPosition] -> ShowS)
-> Show StructureRubyPosition
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StructureRubyPosition] -> ShowS
$cshowList :: [StructureRubyPosition] -> ShowS
show :: StructureRubyPosition -> String
$cshow :: StructureRubyPosition -> String
showsPrec :: Int -> StructureRubyPosition -> ShowS
$cshowsPrec :: Int -> StructureRubyPosition -> ShowS
Show, StructureRubyPosition -> StructureRubyPosition -> Bool
(StructureRubyPosition -> StructureRubyPosition -> Bool)
-> (StructureRubyPosition -> StructureRubyPosition -> Bool)
-> Eq StructureRubyPosition
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StructureRubyPosition -> StructureRubyPosition -> Bool
$c/= :: StructureRubyPosition -> StructureRubyPosition -> Bool
== :: StructureRubyPosition -> StructureRubyPosition -> Bool
$c== :: StructureRubyPosition -> StructureRubyPosition -> Bool
Eq)

instance P.Enum StructureRubyPosition where
    fromEnum :: StructureRubyPosition -> Int
fromEnum StructureRubyPosition
StructureRubyPositionBefore = Int
0
    fromEnum StructureRubyPosition
StructureRubyPositionAfter = Int
1
    fromEnum StructureRubyPosition
StructureRubyPositionWarichu = Int
2
    fromEnum StructureRubyPosition
StructureRubyPositionInline = Int
3
    fromEnum (AnotherStructureRubyPosition Int
k) = Int
k

    toEnum :: Int -> StructureRubyPosition
toEnum Int
0 = StructureRubyPosition
StructureRubyPositionBefore
    toEnum Int
1 = StructureRubyPosition
StructureRubyPositionAfter
    toEnum Int
2 = StructureRubyPosition
StructureRubyPositionWarichu
    toEnum Int
3 = StructureRubyPosition
StructureRubyPositionInline
    toEnum Int
k = Int -> StructureRubyPosition
AnotherStructureRubyPosition Int
k

instance P.Ord StructureRubyPosition where
    compare :: StructureRubyPosition -> StructureRubyPosition -> Ordering
compare StructureRubyPosition
a StructureRubyPosition
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (StructureRubyPosition -> Int
forall a. Enum a => a -> Int
P.fromEnum StructureRubyPosition
a) (StructureRubyPosition -> Int
forall a. Enum a => a -> Int
P.fromEnum StructureRubyPosition
b)

type instance O.ParentTypes StructureRubyPosition = '[]
instance O.HasParentTypes StructureRubyPosition

foreign import ccall "poppler_structure_ruby_position_get_type" c_poppler_structure_ruby_position_get_type :: 
    IO GType

instance B.Types.TypedObject StructureRubyPosition where
    glibType :: IO GType
glibType = IO GType
c_poppler_structure_ruby_position_get_type

instance B.Types.BoxedEnum StructureRubyPosition

-- 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 (Int -> StructureRubyAlign -> ShowS
[StructureRubyAlign] -> ShowS
StructureRubyAlign -> String
(Int -> StructureRubyAlign -> ShowS)
-> (StructureRubyAlign -> String)
-> ([StructureRubyAlign] -> ShowS)
-> Show StructureRubyAlign
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StructureRubyAlign] -> ShowS
$cshowList :: [StructureRubyAlign] -> ShowS
show :: StructureRubyAlign -> String
$cshow :: StructureRubyAlign -> String
showsPrec :: Int -> StructureRubyAlign -> ShowS
$cshowsPrec :: Int -> StructureRubyAlign -> ShowS
Show, StructureRubyAlign -> StructureRubyAlign -> Bool
(StructureRubyAlign -> StructureRubyAlign -> Bool)
-> (StructureRubyAlign -> StructureRubyAlign -> Bool)
-> Eq StructureRubyAlign
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StructureRubyAlign -> StructureRubyAlign -> Bool
$c/= :: StructureRubyAlign -> StructureRubyAlign -> Bool
== :: StructureRubyAlign -> StructureRubyAlign -> Bool
$c== :: StructureRubyAlign -> StructureRubyAlign -> Bool
Eq)

instance P.Enum StructureRubyAlign where
    fromEnum :: StructureRubyAlign -> Int
fromEnum StructureRubyAlign
StructureRubyAlignStart = Int
0
    fromEnum StructureRubyAlign
StructureRubyAlignCenter = Int
1
    fromEnum StructureRubyAlign
StructureRubyAlignEnd = Int
2
    fromEnum StructureRubyAlign
StructureRubyAlignJustify = Int
3
    fromEnum StructureRubyAlign
StructureRubyAlignDistribute = Int
4
    fromEnum (AnotherStructureRubyAlign Int
k) = Int
k

    toEnum :: Int -> StructureRubyAlign
toEnum Int
0 = StructureRubyAlign
StructureRubyAlignStart
    toEnum Int
1 = StructureRubyAlign
StructureRubyAlignCenter
    toEnum Int
2 = StructureRubyAlign
StructureRubyAlignEnd
    toEnum Int
3 = StructureRubyAlign
StructureRubyAlignJustify
    toEnum Int
4 = StructureRubyAlign
StructureRubyAlignDistribute
    toEnum Int
k = Int -> StructureRubyAlign
AnotherStructureRubyAlign Int
k

instance P.Ord StructureRubyAlign where
    compare :: StructureRubyAlign -> StructureRubyAlign -> Ordering
compare StructureRubyAlign
a StructureRubyAlign
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (StructureRubyAlign -> Int
forall a. Enum a => a -> Int
P.fromEnum StructureRubyAlign
a) (StructureRubyAlign -> Int
forall a. Enum a => a -> Int
P.fromEnum StructureRubyAlign
b)

type instance O.ParentTypes StructureRubyAlign = '[]
instance O.HasParentTypes StructureRubyAlign

foreign import ccall "poppler_structure_ruby_align_get_type" c_poppler_structure_ruby_align_get_type :: 
    IO GType

instance B.Types.TypedObject StructureRubyAlign where
    glibType :: IO GType
glibType = IO GType
c_poppler_structure_ruby_align_get_type

instance B.Types.BoxedEnum StructureRubyAlign

-- 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 (Int -> StructurePlacement -> ShowS
[StructurePlacement] -> ShowS
StructurePlacement -> String
(Int -> StructurePlacement -> ShowS)
-> (StructurePlacement -> String)
-> ([StructurePlacement] -> ShowS)
-> Show StructurePlacement
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StructurePlacement] -> ShowS
$cshowList :: [StructurePlacement] -> ShowS
show :: StructurePlacement -> String
$cshow :: StructurePlacement -> String
showsPrec :: Int -> StructurePlacement -> ShowS
$cshowsPrec :: Int -> StructurePlacement -> ShowS
Show, StructurePlacement -> StructurePlacement -> Bool
(StructurePlacement -> StructurePlacement -> Bool)
-> (StructurePlacement -> StructurePlacement -> Bool)
-> Eq StructurePlacement
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StructurePlacement -> StructurePlacement -> Bool
$c/= :: StructurePlacement -> StructurePlacement -> Bool
== :: StructurePlacement -> StructurePlacement -> Bool
$c== :: StructurePlacement -> StructurePlacement -> Bool
Eq)

instance P.Enum StructurePlacement where
    fromEnum :: StructurePlacement -> Int
fromEnum StructurePlacement
StructurePlacementBlock = Int
0
    fromEnum StructurePlacement
StructurePlacementInline = Int
1
    fromEnum StructurePlacement
StructurePlacementBefore = Int
2
    fromEnum StructurePlacement
StructurePlacementStart = Int
3
    fromEnum StructurePlacement
StructurePlacementEnd = Int
4
    fromEnum (AnotherStructurePlacement Int
k) = Int
k

    toEnum :: Int -> StructurePlacement
toEnum Int
0 = StructurePlacement
StructurePlacementBlock
    toEnum Int
1 = StructurePlacement
StructurePlacementInline
    toEnum Int
2 = StructurePlacement
StructurePlacementBefore
    toEnum Int
3 = StructurePlacement
StructurePlacementStart
    toEnum Int
4 = StructurePlacement
StructurePlacementEnd
    toEnum Int
k = Int -> StructurePlacement
AnotherStructurePlacement Int
k

instance P.Ord StructurePlacement where
    compare :: StructurePlacement -> StructurePlacement -> Ordering
compare StructurePlacement
a StructurePlacement
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (StructurePlacement -> Int
forall a. Enum a => a -> Int
P.fromEnum StructurePlacement
a) (StructurePlacement -> Int
forall a. Enum a => a -> Int
P.fromEnum StructurePlacement
b)

type instance O.ParentTypes StructurePlacement = '[]
instance O.HasParentTypes StructurePlacement

foreign import ccall "poppler_structure_placement_get_type" c_poppler_structure_placement_get_type :: 
    IO GType

instance B.Types.TypedObject StructurePlacement where
    glibType :: IO GType
glibType = IO GType
c_poppler_structure_placement_get_type

instance B.Types.BoxedEnum StructurePlacement

-- 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 (Int -> StructureListNumbering -> ShowS
[StructureListNumbering] -> ShowS
StructureListNumbering -> String
(Int -> StructureListNumbering -> ShowS)
-> (StructureListNumbering -> String)
-> ([StructureListNumbering] -> ShowS)
-> Show StructureListNumbering
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StructureListNumbering] -> ShowS
$cshowList :: [StructureListNumbering] -> ShowS
show :: StructureListNumbering -> String
$cshow :: StructureListNumbering -> String
showsPrec :: Int -> StructureListNumbering -> ShowS
$cshowsPrec :: Int -> StructureListNumbering -> ShowS
Show, StructureListNumbering -> StructureListNumbering -> Bool
(StructureListNumbering -> StructureListNumbering -> Bool)
-> (StructureListNumbering -> StructureListNumbering -> Bool)
-> Eq StructureListNumbering
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StructureListNumbering -> StructureListNumbering -> Bool
$c/= :: StructureListNumbering -> StructureListNumbering -> Bool
== :: StructureListNumbering -> StructureListNumbering -> Bool
$c== :: StructureListNumbering -> StructureListNumbering -> Bool
Eq)

instance P.Enum StructureListNumbering where
    fromEnum :: StructureListNumbering -> Int
fromEnum StructureListNumbering
StructureListNumberingNone = Int
0
    fromEnum StructureListNumbering
StructureListNumberingDisc = Int
1
    fromEnum StructureListNumbering
StructureListNumberingCircle = Int
2
    fromEnum StructureListNumbering
StructureListNumberingSquare = Int
3
    fromEnum StructureListNumbering
StructureListNumberingDecimal = Int
4
    fromEnum StructureListNumbering
StructureListNumberingUpperRoman = Int
5
    fromEnum StructureListNumbering
StructureListNumberingLowerRoman = Int
6
    fromEnum StructureListNumbering
StructureListNumberingUpperAlpha = Int
7
    fromEnum StructureListNumbering
StructureListNumberingLowerAlpha = Int
8
    fromEnum (AnotherStructureListNumbering Int
k) = Int
k

    toEnum :: Int -> StructureListNumbering
toEnum Int
0 = StructureListNumbering
StructureListNumberingNone
    toEnum Int
1 = StructureListNumbering
StructureListNumberingDisc
    toEnum Int
2 = StructureListNumbering
StructureListNumberingCircle
    toEnum Int
3 = StructureListNumbering
StructureListNumberingSquare
    toEnum Int
4 = StructureListNumbering
StructureListNumberingDecimal
    toEnum Int
5 = StructureListNumbering
StructureListNumberingUpperRoman
    toEnum Int
6 = StructureListNumbering
StructureListNumberingLowerRoman
    toEnum Int
7 = StructureListNumbering
StructureListNumberingUpperAlpha
    toEnum Int
8 = StructureListNumbering
StructureListNumberingLowerAlpha
    toEnum Int
k = Int -> StructureListNumbering
AnotherStructureListNumbering Int
k

instance P.Ord StructureListNumbering where
    compare :: StructureListNumbering -> StructureListNumbering -> Ordering
compare StructureListNumbering
a StructureListNumbering
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (StructureListNumbering -> Int
forall a. Enum a => a -> Int
P.fromEnum StructureListNumbering
a) (StructureListNumbering -> Int
forall a. Enum a => a -> Int
P.fromEnum StructureListNumbering
b)

type instance O.ParentTypes StructureListNumbering = '[]
instance O.HasParentTypes StructureListNumbering

foreign import ccall "poppler_structure_list_numbering_get_type" c_poppler_structure_list_numbering_get_type :: 
    IO GType

instance B.Types.TypedObject StructureListNumbering where
    glibType :: IO GType
glibType = IO GType
c_poppler_structure_list_numbering_get_type

instance B.Types.BoxedEnum StructureListNumbering

-- 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 (Int -> StructureInlineAlign -> ShowS
[StructureInlineAlign] -> ShowS
StructureInlineAlign -> String
(Int -> StructureInlineAlign -> ShowS)
-> (StructureInlineAlign -> String)
-> ([StructureInlineAlign] -> ShowS)
-> Show StructureInlineAlign
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StructureInlineAlign] -> ShowS
$cshowList :: [StructureInlineAlign] -> ShowS
show :: StructureInlineAlign -> String
$cshow :: StructureInlineAlign -> String
showsPrec :: Int -> StructureInlineAlign -> ShowS
$cshowsPrec :: Int -> StructureInlineAlign -> ShowS
Show, StructureInlineAlign -> StructureInlineAlign -> Bool
(StructureInlineAlign -> StructureInlineAlign -> Bool)
-> (StructureInlineAlign -> StructureInlineAlign -> Bool)
-> Eq StructureInlineAlign
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StructureInlineAlign -> StructureInlineAlign -> Bool
$c/= :: StructureInlineAlign -> StructureInlineAlign -> Bool
== :: StructureInlineAlign -> StructureInlineAlign -> Bool
$c== :: StructureInlineAlign -> StructureInlineAlign -> Bool
Eq)

instance P.Enum StructureInlineAlign where
    fromEnum :: StructureInlineAlign -> Int
fromEnum StructureInlineAlign
StructureInlineAlignStart = Int
0
    fromEnum StructureInlineAlign
StructureInlineAlignCenter = Int
1
    fromEnum StructureInlineAlign
StructureInlineAlignEnd = Int
2
    fromEnum (AnotherStructureInlineAlign Int
k) = Int
k

    toEnum :: Int -> StructureInlineAlign
toEnum Int
0 = StructureInlineAlign
StructureInlineAlignStart
    toEnum Int
1 = StructureInlineAlign
StructureInlineAlignCenter
    toEnum Int
2 = StructureInlineAlign
StructureInlineAlignEnd
    toEnum Int
k = Int -> StructureInlineAlign
AnotherStructureInlineAlign Int
k

instance P.Ord StructureInlineAlign where
    compare :: StructureInlineAlign -> StructureInlineAlign -> Ordering
compare StructureInlineAlign
a StructureInlineAlign
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (StructureInlineAlign -> Int
forall a. Enum a => a -> Int
P.fromEnum StructureInlineAlign
a) (StructureInlineAlign -> Int
forall a. Enum a => a -> Int
P.fromEnum StructureInlineAlign
b)

type instance O.ParentTypes StructureInlineAlign = '[]
instance O.HasParentTypes StructureInlineAlign

foreign import ccall "poppler_structure_inline_align_get_type" c_poppler_structure_inline_align_get_type :: 
    IO GType

instance B.Types.TypedObject StructureInlineAlign where
    glibType :: IO GType
glibType = IO GType
c_poppler_structure_inline_align_get_type

instance B.Types.BoxedEnum StructureInlineAlign

-- 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 (Int -> StructureGlyphOrientation -> ShowS
[StructureGlyphOrientation] -> ShowS
StructureGlyphOrientation -> String
(Int -> StructureGlyphOrientation -> ShowS)
-> (StructureGlyphOrientation -> String)
-> ([StructureGlyphOrientation] -> ShowS)
-> Show StructureGlyphOrientation
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StructureGlyphOrientation] -> ShowS
$cshowList :: [StructureGlyphOrientation] -> ShowS
show :: StructureGlyphOrientation -> String
$cshow :: StructureGlyphOrientation -> String
showsPrec :: Int -> StructureGlyphOrientation -> ShowS
$cshowsPrec :: Int -> StructureGlyphOrientation -> ShowS
Show, StructureGlyphOrientation -> StructureGlyphOrientation -> Bool
(StructureGlyphOrientation -> StructureGlyphOrientation -> Bool)
-> (StructureGlyphOrientation -> StructureGlyphOrientation -> Bool)
-> Eq StructureGlyphOrientation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StructureGlyphOrientation -> StructureGlyphOrientation -> Bool
$c/= :: StructureGlyphOrientation -> StructureGlyphOrientation -> Bool
== :: StructureGlyphOrientation -> StructureGlyphOrientation -> Bool
$c== :: StructureGlyphOrientation -> StructureGlyphOrientation -> Bool
Eq)

instance P.Enum StructureGlyphOrientation where
    fromEnum :: StructureGlyphOrientation -> Int
fromEnum StructureGlyphOrientation
StructureGlyphOrientationAuto = Int
0
    fromEnum StructureGlyphOrientation
StructureGlyphOrientation0 = Int
0
    fromEnum StructureGlyphOrientation
StructureGlyphOrientation90 = Int
1
    fromEnum StructureGlyphOrientation
StructureGlyphOrientation180 = Int
2
    fromEnum StructureGlyphOrientation
StructureGlyphOrientation270 = Int
3
    fromEnum (AnotherStructureGlyphOrientation Int
k) = Int
k

    toEnum :: Int -> StructureGlyphOrientation
toEnum Int
0 = StructureGlyphOrientation
StructureGlyphOrientationAuto
    toEnum Int
1 = StructureGlyphOrientation
StructureGlyphOrientation90
    toEnum Int
2 = StructureGlyphOrientation
StructureGlyphOrientation180
    toEnum Int
3 = StructureGlyphOrientation
StructureGlyphOrientation270
    toEnum Int
k = Int -> StructureGlyphOrientation
AnotherStructureGlyphOrientation Int
k

instance P.Ord StructureGlyphOrientation where
    compare :: StructureGlyphOrientation -> StructureGlyphOrientation -> Ordering
compare StructureGlyphOrientation
a StructureGlyphOrientation
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (StructureGlyphOrientation -> Int
forall a. Enum a => a -> Int
P.fromEnum StructureGlyphOrientation
a) (StructureGlyphOrientation -> Int
forall a. Enum a => a -> Int
P.fromEnum StructureGlyphOrientation
b)

type instance O.ParentTypes StructureGlyphOrientation = '[]
instance O.HasParentTypes StructureGlyphOrientation

foreign import ccall "poppler_structure_glyph_orientation_get_type" c_poppler_structure_glyph_orientation_get_type :: 
    IO GType

instance B.Types.TypedObject StructureGlyphOrientation where
    glibType :: IO GType
glibType = IO GType
c_poppler_structure_glyph_orientation_get_type

instance B.Types.BoxedEnum StructureGlyphOrientation

-- 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 (Int -> StructureFormState -> ShowS
[StructureFormState] -> ShowS
StructureFormState -> String
(Int -> StructureFormState -> ShowS)
-> (StructureFormState -> String)
-> ([StructureFormState] -> ShowS)
-> Show StructureFormState
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StructureFormState] -> ShowS
$cshowList :: [StructureFormState] -> ShowS
show :: StructureFormState -> String
$cshow :: StructureFormState -> String
showsPrec :: Int -> StructureFormState -> ShowS
$cshowsPrec :: Int -> StructureFormState -> ShowS
Show, StructureFormState -> StructureFormState -> Bool
(StructureFormState -> StructureFormState -> Bool)
-> (StructureFormState -> StructureFormState -> Bool)
-> Eq StructureFormState
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StructureFormState -> StructureFormState -> Bool
$c/= :: StructureFormState -> StructureFormState -> Bool
== :: StructureFormState -> StructureFormState -> Bool
$c== :: StructureFormState -> StructureFormState -> Bool
Eq)

instance P.Enum StructureFormState where
    fromEnum :: StructureFormState -> Int
fromEnum StructureFormState
StructureFormStateOn = Int
0
    fromEnum StructureFormState
StructureFormStateOff = Int
1
    fromEnum StructureFormState
StructureFormStateNeutral = Int
2
    fromEnum (AnotherStructureFormState Int
k) = Int
k

    toEnum :: Int -> StructureFormState
toEnum Int
0 = StructureFormState
StructureFormStateOn
    toEnum Int
1 = StructureFormState
StructureFormStateOff
    toEnum Int
2 = StructureFormState
StructureFormStateNeutral
    toEnum Int
k = Int -> StructureFormState
AnotherStructureFormState Int
k

instance P.Ord StructureFormState where
    compare :: StructureFormState -> StructureFormState -> Ordering
compare StructureFormState
a StructureFormState
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (StructureFormState -> Int
forall a. Enum a => a -> Int
P.fromEnum StructureFormState
a) (StructureFormState -> Int
forall a. Enum a => a -> Int
P.fromEnum StructureFormState
b)

type instance O.ParentTypes StructureFormState = '[]
instance O.HasParentTypes StructureFormState

foreign import ccall "poppler_structure_form_state_get_type" c_poppler_structure_form_state_get_type :: 
    IO GType

instance B.Types.TypedObject StructureFormState where
    glibType :: IO GType
glibType = IO GType
c_poppler_structure_form_state_get_type

instance B.Types.BoxedEnum StructureFormState

-- 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 (Int -> StructureFormRole -> ShowS
[StructureFormRole] -> ShowS
StructureFormRole -> String
(Int -> StructureFormRole -> ShowS)
-> (StructureFormRole -> String)
-> ([StructureFormRole] -> ShowS)
-> Show StructureFormRole
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StructureFormRole] -> ShowS
$cshowList :: [StructureFormRole] -> ShowS
show :: StructureFormRole -> String
$cshow :: StructureFormRole -> String
showsPrec :: Int -> StructureFormRole -> ShowS
$cshowsPrec :: Int -> StructureFormRole -> ShowS
Show, StructureFormRole -> StructureFormRole -> Bool
(StructureFormRole -> StructureFormRole -> Bool)
-> (StructureFormRole -> StructureFormRole -> Bool)
-> Eq StructureFormRole
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StructureFormRole -> StructureFormRole -> Bool
$c/= :: StructureFormRole -> StructureFormRole -> Bool
== :: StructureFormRole -> StructureFormRole -> Bool
$c== :: StructureFormRole -> StructureFormRole -> Bool
Eq)

instance P.Enum StructureFormRole where
    fromEnum :: StructureFormRole -> Int
fromEnum StructureFormRole
StructureFormRoleUndefined = Int
0
    fromEnum StructureFormRole
StructureFormRoleRadioButton = Int
1
    fromEnum StructureFormRole
StructureFormRolePushButton = Int
2
    fromEnum StructureFormRole
StructureFormRoleTextValue = Int
3
    fromEnum StructureFormRole
StructureFormRoleCheckbox = Int
4
    fromEnum (AnotherStructureFormRole Int
k) = Int
k

    toEnum :: Int -> StructureFormRole
toEnum Int
0 = StructureFormRole
StructureFormRoleUndefined
    toEnum Int
1 = StructureFormRole
StructureFormRoleRadioButton
    toEnum Int
2 = StructureFormRole
StructureFormRolePushButton
    toEnum Int
3 = StructureFormRole
StructureFormRoleTextValue
    toEnum Int
4 = StructureFormRole
StructureFormRoleCheckbox
    toEnum Int
k = Int -> StructureFormRole
AnotherStructureFormRole Int
k

instance P.Ord StructureFormRole where
    compare :: StructureFormRole -> StructureFormRole -> Ordering
compare StructureFormRole
a StructureFormRole
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (StructureFormRole -> Int
forall a. Enum a => a -> Int
P.fromEnum StructureFormRole
a) (StructureFormRole -> Int
forall a. Enum a => a -> Int
P.fromEnum StructureFormRole
b)

type instance O.ParentTypes StructureFormRole = '[]
instance O.HasParentTypes StructureFormRole

foreign import ccall "poppler_structure_form_role_get_type" c_poppler_structure_form_role_get_type :: 
    IO GType

instance B.Types.TypedObject StructureFormRole where
    glibType :: IO GType
glibType = IO GType
c_poppler_structure_form_role_get_type

instance B.Types.BoxedEnum StructureFormRole

-- 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 (Int -> StructureElementKind -> ShowS
[StructureElementKind] -> ShowS
StructureElementKind -> String
(Int -> StructureElementKind -> ShowS)
-> (StructureElementKind -> String)
-> ([StructureElementKind] -> ShowS)
-> Show StructureElementKind
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StructureElementKind] -> ShowS
$cshowList :: [StructureElementKind] -> ShowS
show :: StructureElementKind -> String
$cshow :: StructureElementKind -> String
showsPrec :: Int -> StructureElementKind -> ShowS
$cshowsPrec :: Int -> StructureElementKind -> ShowS
Show, StructureElementKind -> StructureElementKind -> Bool
(StructureElementKind -> StructureElementKind -> Bool)
-> (StructureElementKind -> StructureElementKind -> Bool)
-> Eq StructureElementKind
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StructureElementKind -> StructureElementKind -> Bool
$c/= :: StructureElementKind -> StructureElementKind -> Bool
== :: StructureElementKind -> StructureElementKind -> Bool
$c== :: StructureElementKind -> StructureElementKind -> Bool
Eq)

instance P.Enum StructureElementKind where
    fromEnum :: StructureElementKind -> Int
fromEnum StructureElementKind
StructureElementKindContent = Int
0
    fromEnum StructureElementKind
StructureElementKindObjectReference = Int
1
    fromEnum StructureElementKind
StructureElementKindDocument = Int
2
    fromEnum StructureElementKind
StructureElementKindPart = Int
3
    fromEnum StructureElementKind
StructureElementKindArticle = Int
4
    fromEnum StructureElementKind
StructureElementKindSection = Int
5
    fromEnum StructureElementKind
StructureElementKindDiv = Int
6
    fromEnum StructureElementKind
StructureElementKindSpan = Int
7
    fromEnum StructureElementKind
StructureElementKindQuote = Int
8
    fromEnum StructureElementKind
StructureElementKindNote = Int
9
    fromEnum StructureElementKind
StructureElementKindReference = Int
10
    fromEnum StructureElementKind
StructureElementKindBibentry = Int
11
    fromEnum StructureElementKind
StructureElementKindCode = Int
12
    fromEnum StructureElementKind
StructureElementKindLink = Int
13
    fromEnum StructureElementKind
StructureElementKindAnnot = Int
14
    fromEnum StructureElementKind
StructureElementKindBlockquote = Int
15
    fromEnum StructureElementKind
StructureElementKindCaption = Int
16
    fromEnum StructureElementKind
StructureElementKindNonstruct = Int
17
    fromEnum StructureElementKind
StructureElementKindToc = Int
18
    fromEnum StructureElementKind
StructureElementKindTocItem = Int
19
    fromEnum StructureElementKind
StructureElementKindIndex = Int
20
    fromEnum StructureElementKind
StructureElementKindPrivate = Int
21
    fromEnum StructureElementKind
StructureElementKindParagraph = Int
22
    fromEnum StructureElementKind
StructureElementKindHeading = Int
23
    fromEnum StructureElementKind
StructureElementKindHeading1 = Int
24
    fromEnum StructureElementKind
StructureElementKindHeading2 = Int
25
    fromEnum StructureElementKind
StructureElementKindHeading3 = Int
26
    fromEnum StructureElementKind
StructureElementKindHeading4 = Int
27
    fromEnum StructureElementKind
StructureElementKindHeading5 = Int
28
    fromEnum StructureElementKind
StructureElementKindHeading6 = Int
29
    fromEnum StructureElementKind
StructureElementKindList = Int
30
    fromEnum StructureElementKind
StructureElementKindListItem = Int
31
    fromEnum StructureElementKind
StructureElementKindListLabel = Int
32
    fromEnum StructureElementKind
StructureElementKindListBody = Int
33
    fromEnum StructureElementKind
StructureElementKindTable = Int
34
    fromEnum StructureElementKind
StructureElementKindTableRow = Int
35
    fromEnum StructureElementKind
StructureElementKindTableHeading = Int
36
    fromEnum StructureElementKind
StructureElementKindTableData = Int
37
    fromEnum StructureElementKind
StructureElementKindTableHeader = Int
38
    fromEnum StructureElementKind
StructureElementKindTableFooter = Int
39
    fromEnum StructureElementKind
StructureElementKindTableBody = Int
40
    fromEnum StructureElementKind
StructureElementKindRuby = Int
41
    fromEnum StructureElementKind
StructureElementKindRubyBaseText = Int
42
    fromEnum StructureElementKind
StructureElementKindRubyAnnotText = Int
43
    fromEnum StructureElementKind
StructureElementKindRubyPunctuation = Int
44
    fromEnum StructureElementKind
StructureElementKindWarichu = Int
45
    fromEnum StructureElementKind
StructureElementKindWarichuText = Int
46
    fromEnum StructureElementKind
StructureElementKindWarichuPunctuation = Int
47
    fromEnum StructureElementKind
StructureElementKindFigure = Int
48
    fromEnum StructureElementKind
StructureElementKindFormula = Int
49
    fromEnum StructureElementKind
StructureElementKindForm = Int
50
    fromEnum (AnotherStructureElementKind Int
k) = Int
k

    toEnum :: Int -> StructureElementKind
toEnum Int
0 = StructureElementKind
StructureElementKindContent
    toEnum Int
1 = StructureElementKind
StructureElementKindObjectReference
    toEnum Int
2 = StructureElementKind
StructureElementKindDocument
    toEnum Int
3 = StructureElementKind
StructureElementKindPart
    toEnum Int
4 = StructureElementKind
StructureElementKindArticle
    toEnum Int
5 = StructureElementKind
StructureElementKindSection
    toEnum Int
6 = StructureElementKind
StructureElementKindDiv
    toEnum Int
7 = StructureElementKind
StructureElementKindSpan
    toEnum Int
8 = StructureElementKind
StructureElementKindQuote
    toEnum Int
9 = StructureElementKind
StructureElementKindNote
    toEnum Int
10 = StructureElementKind
StructureElementKindReference
    toEnum Int
11 = StructureElementKind
StructureElementKindBibentry
    toEnum Int
12 = StructureElementKind
StructureElementKindCode
    toEnum Int
13 = StructureElementKind
StructureElementKindLink
    toEnum Int
14 = StructureElementKind
StructureElementKindAnnot
    toEnum Int
15 = StructureElementKind
StructureElementKindBlockquote
    toEnum Int
16 = StructureElementKind
StructureElementKindCaption
    toEnum Int
17 = StructureElementKind
StructureElementKindNonstruct
    toEnum Int
18 = StructureElementKind
StructureElementKindToc
    toEnum Int
19 = StructureElementKind
StructureElementKindTocItem
    toEnum Int
20 = StructureElementKind
StructureElementKindIndex
    toEnum Int
21 = StructureElementKind
StructureElementKindPrivate
    toEnum Int
22 = StructureElementKind
StructureElementKindParagraph
    toEnum Int
23 = StructureElementKind
StructureElementKindHeading
    toEnum Int
24 = StructureElementKind
StructureElementKindHeading1
    toEnum Int
25 = StructureElementKind
StructureElementKindHeading2
    toEnum Int
26 = StructureElementKind
StructureElementKindHeading3
    toEnum Int
27 = StructureElementKind
StructureElementKindHeading4
    toEnum Int
28 = StructureElementKind
StructureElementKindHeading5
    toEnum Int
29 = StructureElementKind
StructureElementKindHeading6
    toEnum Int
30 = StructureElementKind
StructureElementKindList
    toEnum Int
31 = StructureElementKind
StructureElementKindListItem
    toEnum Int
32 = StructureElementKind
StructureElementKindListLabel
    toEnum Int
33 = StructureElementKind
StructureElementKindListBody
    toEnum Int
34 = StructureElementKind
StructureElementKindTable
    toEnum Int
35 = StructureElementKind
StructureElementKindTableRow
    toEnum Int
36 = StructureElementKind
StructureElementKindTableHeading
    toEnum Int
37 = StructureElementKind
StructureElementKindTableData
    toEnum Int
38 = StructureElementKind
StructureElementKindTableHeader
    toEnum Int
39 = StructureElementKind
StructureElementKindTableFooter
    toEnum Int
40 = StructureElementKind
StructureElementKindTableBody
    toEnum Int
41 = StructureElementKind
StructureElementKindRuby
    toEnum Int
42 = StructureElementKind
StructureElementKindRubyBaseText
    toEnum Int
43 = StructureElementKind
StructureElementKindRubyAnnotText
    toEnum Int
44 = StructureElementKind
StructureElementKindRubyPunctuation
    toEnum Int
45 = StructureElementKind
StructureElementKindWarichu
    toEnum Int
46 = StructureElementKind
StructureElementKindWarichuText
    toEnum Int
47 = StructureElementKind
StructureElementKindWarichuPunctuation
    toEnum Int
48 = StructureElementKind
StructureElementKindFigure
    toEnum Int
49 = StructureElementKind
StructureElementKindFormula
    toEnum Int
50 = StructureElementKind
StructureElementKindForm
    toEnum Int
k = Int -> StructureElementKind
AnotherStructureElementKind Int
k

instance P.Ord StructureElementKind where
    compare :: StructureElementKind -> StructureElementKind -> Ordering
compare StructureElementKind
a StructureElementKind
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (StructureElementKind -> Int
forall a. Enum a => a -> Int
P.fromEnum StructureElementKind
a) (StructureElementKind -> Int
forall a. Enum a => a -> Int
P.fromEnum StructureElementKind
b)

type instance O.ParentTypes StructureElementKind = '[]
instance O.HasParentTypes StructureElementKind

foreign import ccall "poppler_structure_element_kind_get_type" c_poppler_structure_element_kind_get_type :: 
    IO GType

instance B.Types.TypedObject StructureElementKind where
    glibType :: IO GType
glibType = IO GType
c_poppler_structure_element_kind_get_type

instance B.Types.BoxedEnum StructureElementKind

-- 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 (Int -> StructureBorderStyle -> ShowS
[StructureBorderStyle] -> ShowS
StructureBorderStyle -> String
(Int -> StructureBorderStyle -> ShowS)
-> (StructureBorderStyle -> String)
-> ([StructureBorderStyle] -> ShowS)
-> Show StructureBorderStyle
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StructureBorderStyle] -> ShowS
$cshowList :: [StructureBorderStyle] -> ShowS
show :: StructureBorderStyle -> String
$cshow :: StructureBorderStyle -> String
showsPrec :: Int -> StructureBorderStyle -> ShowS
$cshowsPrec :: Int -> StructureBorderStyle -> ShowS
Show, StructureBorderStyle -> StructureBorderStyle -> Bool
(StructureBorderStyle -> StructureBorderStyle -> Bool)
-> (StructureBorderStyle -> StructureBorderStyle -> Bool)
-> Eq StructureBorderStyle
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StructureBorderStyle -> StructureBorderStyle -> Bool
$c/= :: StructureBorderStyle -> StructureBorderStyle -> Bool
== :: StructureBorderStyle -> StructureBorderStyle -> Bool
$c== :: StructureBorderStyle -> StructureBorderStyle -> Bool
Eq)

instance P.Enum StructureBorderStyle where
    fromEnum :: StructureBorderStyle -> Int
fromEnum StructureBorderStyle
StructureBorderStyleNone = Int
0
    fromEnum StructureBorderStyle
StructureBorderStyleHidden = Int
1
    fromEnum StructureBorderStyle
StructureBorderStyleDotted = Int
2
    fromEnum StructureBorderStyle
StructureBorderStyleDashed = Int
3
    fromEnum StructureBorderStyle
StructureBorderStyleSolid = Int
4
    fromEnum StructureBorderStyle
StructureBorderStyleDouble = Int
5
    fromEnum StructureBorderStyle
StructureBorderStyleGroove = Int
6
    fromEnum StructureBorderStyle
StructureBorderStyleInset = Int
7
    fromEnum StructureBorderStyle
StructureBorderStyleOutset = Int
8
    fromEnum (AnotherStructureBorderStyle Int
k) = Int
k

    toEnum :: Int -> StructureBorderStyle
toEnum Int
0 = StructureBorderStyle
StructureBorderStyleNone
    toEnum Int
1 = StructureBorderStyle
StructureBorderStyleHidden
    toEnum Int
2 = StructureBorderStyle
StructureBorderStyleDotted
    toEnum Int
3 = StructureBorderStyle
StructureBorderStyleDashed
    toEnum Int
4 = StructureBorderStyle
StructureBorderStyleSolid
    toEnum Int
5 = StructureBorderStyle
StructureBorderStyleDouble
    toEnum Int
6 = StructureBorderStyle
StructureBorderStyleGroove
    toEnum Int
7 = StructureBorderStyle
StructureBorderStyleInset
    toEnum Int
8 = StructureBorderStyle
StructureBorderStyleOutset
    toEnum Int
k = Int -> StructureBorderStyle
AnotherStructureBorderStyle Int
k

instance P.Ord StructureBorderStyle where
    compare :: StructureBorderStyle -> StructureBorderStyle -> Ordering
compare StructureBorderStyle
a StructureBorderStyle
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (StructureBorderStyle -> Int
forall a. Enum a => a -> Int
P.fromEnum StructureBorderStyle
a) (StructureBorderStyle -> Int
forall a. Enum a => a -> Int
P.fromEnum StructureBorderStyle
b)

type instance O.ParentTypes StructureBorderStyle = '[]
instance O.HasParentTypes StructureBorderStyle

foreign import ccall "poppler_structure_border_style_get_type" c_poppler_structure_border_style_get_type :: 
    IO GType

instance B.Types.TypedObject StructureBorderStyle where
    glibType :: IO GType
glibType = IO GType
c_poppler_structure_border_style_get_type

instance B.Types.BoxedEnum StructureBorderStyle

-- 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 (Int -> StructureBlockAlign -> ShowS
[StructureBlockAlign] -> ShowS
StructureBlockAlign -> String
(Int -> StructureBlockAlign -> ShowS)
-> (StructureBlockAlign -> String)
-> ([StructureBlockAlign] -> ShowS)
-> Show StructureBlockAlign
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StructureBlockAlign] -> ShowS
$cshowList :: [StructureBlockAlign] -> ShowS
show :: StructureBlockAlign -> String
$cshow :: StructureBlockAlign -> String
showsPrec :: Int -> StructureBlockAlign -> ShowS
$cshowsPrec :: Int -> StructureBlockAlign -> ShowS
Show, StructureBlockAlign -> StructureBlockAlign -> Bool
(StructureBlockAlign -> StructureBlockAlign -> Bool)
-> (StructureBlockAlign -> StructureBlockAlign -> Bool)
-> Eq StructureBlockAlign
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StructureBlockAlign -> StructureBlockAlign -> Bool
$c/= :: StructureBlockAlign -> StructureBlockAlign -> Bool
== :: StructureBlockAlign -> StructureBlockAlign -> Bool
$c== :: StructureBlockAlign -> StructureBlockAlign -> Bool
Eq)

instance P.Enum StructureBlockAlign where
    fromEnum :: StructureBlockAlign -> Int
fromEnum StructureBlockAlign
StructureBlockAlignBefore = Int
0
    fromEnum StructureBlockAlign
StructureBlockAlignMiddle = Int
1
    fromEnum StructureBlockAlign
StructureBlockAlignAfter = Int
2
    fromEnum StructureBlockAlign
StructureBlockAlignJustify = Int
3
    fromEnum (AnotherStructureBlockAlign Int
k) = Int
k

    toEnum :: Int -> StructureBlockAlign
toEnum Int
0 = StructureBlockAlign
StructureBlockAlignBefore
    toEnum Int
1 = StructureBlockAlign
StructureBlockAlignMiddle
    toEnum Int
2 = StructureBlockAlign
StructureBlockAlignAfter
    toEnum Int
3 = StructureBlockAlign
StructureBlockAlignJustify
    toEnum Int
k = Int -> StructureBlockAlign
AnotherStructureBlockAlign Int
k

instance P.Ord StructureBlockAlign where
    compare :: StructureBlockAlign -> StructureBlockAlign -> Ordering
compare StructureBlockAlign
a StructureBlockAlign
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (StructureBlockAlign -> Int
forall a. Enum a => a -> Int
P.fromEnum StructureBlockAlign
a) (StructureBlockAlign -> Int
forall a. Enum a => a -> Int
P.fromEnum StructureBlockAlign
b)

type instance O.ParentTypes StructureBlockAlign = '[]
instance O.HasParentTypes StructureBlockAlign

foreign import ccall "poppler_structure_block_align_get_type" c_poppler_structure_block_align_get_type :: 
    IO GType

instance B.Types.TypedObject StructureBlockAlign where
    glibType :: IO GType
glibType = IO GType
c_poppler_structure_block_align_get_type

instance B.Types.BoxedEnum StructureBlockAlign

-- 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 (Int -> SelectionStyle -> ShowS
[SelectionStyle] -> ShowS
SelectionStyle -> String
(Int -> SelectionStyle -> ShowS)
-> (SelectionStyle -> String)
-> ([SelectionStyle] -> ShowS)
-> Show SelectionStyle
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SelectionStyle] -> ShowS
$cshowList :: [SelectionStyle] -> ShowS
show :: SelectionStyle -> String
$cshow :: SelectionStyle -> String
showsPrec :: Int -> SelectionStyle -> ShowS
$cshowsPrec :: Int -> SelectionStyle -> ShowS
Show, SelectionStyle -> SelectionStyle -> Bool
(SelectionStyle -> SelectionStyle -> Bool)
-> (SelectionStyle -> SelectionStyle -> Bool) -> Eq SelectionStyle
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SelectionStyle -> SelectionStyle -> Bool
$c/= :: SelectionStyle -> SelectionStyle -> Bool
== :: SelectionStyle -> SelectionStyle -> Bool
$c== :: SelectionStyle -> SelectionStyle -> Bool
Eq)

instance P.Enum SelectionStyle where
    fromEnum :: SelectionStyle -> Int
fromEnum SelectionStyle
SelectionStyleGlyph = Int
0
    fromEnum SelectionStyle
SelectionStyleWord = Int
1
    fromEnum SelectionStyle
SelectionStyleLine = Int
2
    fromEnum (AnotherSelectionStyle Int
k) = Int
k

    toEnum :: Int -> SelectionStyle
toEnum Int
0 = SelectionStyle
SelectionStyleGlyph
    toEnum Int
1 = SelectionStyle
SelectionStyleWord
    toEnum Int
2 = SelectionStyle
SelectionStyleLine
    toEnum Int
k = Int -> SelectionStyle
AnotherSelectionStyle Int
k

instance P.Ord SelectionStyle where
    compare :: SelectionStyle -> SelectionStyle -> Ordering
compare SelectionStyle
a SelectionStyle
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SelectionStyle -> Int
forall a. Enum a => a -> Int
P.fromEnum SelectionStyle
a) (SelectionStyle -> Int
forall a. Enum a => a -> Int
P.fromEnum SelectionStyle
b)

type instance O.ParentTypes SelectionStyle = '[]
instance O.HasParentTypes SelectionStyle

foreign import ccall "poppler_selection_style_get_type" c_poppler_selection_style_get_type :: 
    IO GType

instance B.Types.TypedObject SelectionStyle where
    glibType :: IO GType
glibType = IO GType
c_poppler_selection_style_get_type

instance B.Types.BoxedEnum SelectionStyle

-- 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 (Int -> PrintScaling -> ShowS
[PrintScaling] -> ShowS
PrintScaling -> String
(Int -> PrintScaling -> ShowS)
-> (PrintScaling -> String)
-> ([PrintScaling] -> ShowS)
-> Show PrintScaling
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PrintScaling] -> ShowS
$cshowList :: [PrintScaling] -> ShowS
show :: PrintScaling -> String
$cshow :: PrintScaling -> String
showsPrec :: Int -> PrintScaling -> ShowS
$cshowsPrec :: Int -> PrintScaling -> ShowS
Show, PrintScaling -> PrintScaling -> Bool
(PrintScaling -> PrintScaling -> Bool)
-> (PrintScaling -> PrintScaling -> Bool) -> Eq PrintScaling
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PrintScaling -> PrintScaling -> Bool
$c/= :: PrintScaling -> PrintScaling -> Bool
== :: PrintScaling -> PrintScaling -> Bool
$c== :: PrintScaling -> PrintScaling -> Bool
Eq)

instance P.Enum PrintScaling where
    fromEnum :: PrintScaling -> Int
fromEnum PrintScaling
PrintScalingAppDefault = Int
0
    fromEnum PrintScaling
PrintScalingNone = Int
1
    fromEnum (AnotherPrintScaling Int
k) = Int
k

    toEnum :: Int -> PrintScaling
toEnum Int
0 = PrintScaling
PrintScalingAppDefault
    toEnum Int
1 = PrintScaling
PrintScalingNone
    toEnum Int
k = Int -> PrintScaling
AnotherPrintScaling Int
k

instance P.Ord PrintScaling where
    compare :: PrintScaling -> PrintScaling -> Ordering
compare PrintScaling
a PrintScaling
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PrintScaling -> Int
forall a. Enum a => a -> Int
P.fromEnum PrintScaling
a) (PrintScaling -> Int
forall a. Enum a => a -> Int
P.fromEnum PrintScaling
b)

type instance O.ParentTypes PrintScaling = '[]
instance O.HasParentTypes PrintScaling

foreign import ccall "poppler_print_scaling_get_type" c_poppler_print_scaling_get_type :: 
    IO GType

instance B.Types.TypedObject PrintScaling where
    glibType :: IO GType
glibType = IO GType
c_poppler_print_scaling_get_type

instance B.Types.BoxedEnum PrintScaling

-- Enum PrintDuplex
-- | Duplex viewer preference
-- 
-- /Since: 0.80/
data PrintDuplex = 
      PrintDuplexNone
    -- ^ No preference on duplex printing
    | PrintDuplexSimplex
    -- ^ Print single-sided
    | PrintDuplexDuplexFlipShortEdge
    -- ^ Duplex and flip on the short edge of the sheet
    | PrintDuplexDuplexFlipLongEdge
    -- ^ Duplex and flip on the long edge of the sheet
    | AnotherPrintDuplex Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PrintDuplex -> ShowS
[PrintDuplex] -> ShowS
PrintDuplex -> String
(Int -> PrintDuplex -> ShowS)
-> (PrintDuplex -> String)
-> ([PrintDuplex] -> ShowS)
-> Show PrintDuplex
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PrintDuplex] -> ShowS
$cshowList :: [PrintDuplex] -> ShowS
show :: PrintDuplex -> String
$cshow :: PrintDuplex -> String
showsPrec :: Int -> PrintDuplex -> ShowS
$cshowsPrec :: Int -> PrintDuplex -> ShowS
Show, PrintDuplex -> PrintDuplex -> Bool
(PrintDuplex -> PrintDuplex -> Bool)
-> (PrintDuplex -> PrintDuplex -> Bool) -> Eq PrintDuplex
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PrintDuplex -> PrintDuplex -> Bool
$c/= :: PrintDuplex -> PrintDuplex -> Bool
== :: PrintDuplex -> PrintDuplex -> Bool
$c== :: PrintDuplex -> PrintDuplex -> Bool
Eq)

instance P.Enum PrintDuplex where
    fromEnum :: PrintDuplex -> Int
fromEnum PrintDuplex
PrintDuplexNone = Int
0
    fromEnum PrintDuplex
PrintDuplexSimplex = Int
1
    fromEnum PrintDuplex
PrintDuplexDuplexFlipShortEdge = Int
2
    fromEnum PrintDuplex
PrintDuplexDuplexFlipLongEdge = Int
3
    fromEnum (AnotherPrintDuplex Int
k) = Int
k

    toEnum :: Int -> PrintDuplex
toEnum Int
0 = PrintDuplex
PrintDuplexNone
    toEnum Int
1 = PrintDuplex
PrintDuplexSimplex
    toEnum Int
2 = PrintDuplex
PrintDuplexDuplexFlipShortEdge
    toEnum Int
3 = PrintDuplex
PrintDuplexDuplexFlipLongEdge
    toEnum Int
k = Int -> PrintDuplex
AnotherPrintDuplex Int
k

instance P.Ord PrintDuplex where
    compare :: PrintDuplex -> PrintDuplex -> Ordering
compare PrintDuplex
a PrintDuplex
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PrintDuplex -> Int
forall a. Enum a => a -> Int
P.fromEnum PrintDuplex
a) (PrintDuplex -> Int
forall a. Enum a => a -> Int
P.fromEnum PrintDuplex
b)

type instance O.ParentTypes PrintDuplex = '[]
instance O.HasParentTypes PrintDuplex

foreign import ccall "poppler_print_duplex_get_type" c_poppler_print_duplex_get_type :: 
    IO GType

instance B.Types.TypedObject PrintDuplex where
    glibType :: IO GType
glibType = IO GType
c_poppler_print_duplex_get_type

instance B.Types.BoxedEnum PrintDuplex

-- 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 (Int -> PageTransitionType -> ShowS
[PageTransitionType] -> ShowS
PageTransitionType -> String
(Int -> PageTransitionType -> ShowS)
-> (PageTransitionType -> String)
-> ([PageTransitionType] -> ShowS)
-> Show PageTransitionType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PageTransitionType] -> ShowS
$cshowList :: [PageTransitionType] -> ShowS
show :: PageTransitionType -> String
$cshow :: PageTransitionType -> String
showsPrec :: Int -> PageTransitionType -> ShowS
$cshowsPrec :: Int -> PageTransitionType -> ShowS
Show, PageTransitionType -> PageTransitionType -> Bool
(PageTransitionType -> PageTransitionType -> Bool)
-> (PageTransitionType -> PageTransitionType -> Bool)
-> Eq PageTransitionType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PageTransitionType -> PageTransitionType -> Bool
$c/= :: PageTransitionType -> PageTransitionType -> Bool
== :: PageTransitionType -> PageTransitionType -> Bool
$c== :: PageTransitionType -> PageTransitionType -> Bool
Eq)

instance P.Enum PageTransitionType where
    fromEnum :: PageTransitionType -> Int
fromEnum PageTransitionType
PageTransitionTypeReplace = Int
0
    fromEnum PageTransitionType
PageTransitionTypeSplit = Int
1
    fromEnum PageTransitionType
PageTransitionTypeBlinds = Int
2
    fromEnum PageTransitionType
PageTransitionTypeBox = Int
3
    fromEnum PageTransitionType
PageTransitionTypeWipe = Int
4
    fromEnum PageTransitionType
PageTransitionTypeDissolve = Int
5
    fromEnum PageTransitionType
PageTransitionTypeGlitter = Int
6
    fromEnum PageTransitionType
PageTransitionTypeFly = Int
7
    fromEnum PageTransitionType
PageTransitionTypePush = Int
8
    fromEnum PageTransitionType
PageTransitionTypeCover = Int
9
    fromEnum PageTransitionType
PageTransitionTypeUncover = Int
10
    fromEnum PageTransitionType
PageTransitionTypeFade = Int
11
    fromEnum (AnotherPageTransitionType Int
k) = Int
k

    toEnum :: Int -> PageTransitionType
toEnum Int
0 = PageTransitionType
PageTransitionTypeReplace
    toEnum Int
1 = PageTransitionType
PageTransitionTypeSplit
    toEnum Int
2 = PageTransitionType
PageTransitionTypeBlinds
    toEnum Int
3 = PageTransitionType
PageTransitionTypeBox
    toEnum Int
4 = PageTransitionType
PageTransitionTypeWipe
    toEnum Int
5 = PageTransitionType
PageTransitionTypeDissolve
    toEnum Int
6 = PageTransitionType
PageTransitionTypeGlitter
    toEnum Int
7 = PageTransitionType
PageTransitionTypeFly
    toEnum Int
8 = PageTransitionType
PageTransitionTypePush
    toEnum Int
9 = PageTransitionType
PageTransitionTypeCover
    toEnum Int
10 = PageTransitionType
PageTransitionTypeUncover
    toEnum Int
11 = PageTransitionType
PageTransitionTypeFade
    toEnum Int
k = Int -> PageTransitionType
AnotherPageTransitionType Int
k

instance P.Ord PageTransitionType where
    compare :: PageTransitionType -> PageTransitionType -> Ordering
compare PageTransitionType
a PageTransitionType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PageTransitionType -> Int
forall a. Enum a => a -> Int
P.fromEnum PageTransitionType
a) (PageTransitionType -> Int
forall a. Enum a => a -> Int
P.fromEnum PageTransitionType
b)

type instance O.ParentTypes PageTransitionType = '[]
instance O.HasParentTypes PageTransitionType

foreign import ccall "poppler_page_transition_type_get_type" c_poppler_page_transition_type_get_type :: 
    IO GType

instance B.Types.TypedObject PageTransitionType where
    glibType :: IO GType
glibType = IO GType
c_poppler_page_transition_type_get_type

instance B.Types.BoxedEnum PageTransitionType

-- 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 (Int -> PageTransitionDirection -> ShowS
[PageTransitionDirection] -> ShowS
PageTransitionDirection -> String
(Int -> PageTransitionDirection -> ShowS)
-> (PageTransitionDirection -> String)
-> ([PageTransitionDirection] -> ShowS)
-> Show PageTransitionDirection
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PageTransitionDirection] -> ShowS
$cshowList :: [PageTransitionDirection] -> ShowS
show :: PageTransitionDirection -> String
$cshow :: PageTransitionDirection -> String
showsPrec :: Int -> PageTransitionDirection -> ShowS
$cshowsPrec :: Int -> PageTransitionDirection -> ShowS
Show, PageTransitionDirection -> PageTransitionDirection -> Bool
(PageTransitionDirection -> PageTransitionDirection -> Bool)
-> (PageTransitionDirection -> PageTransitionDirection -> Bool)
-> Eq PageTransitionDirection
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PageTransitionDirection -> PageTransitionDirection -> Bool
$c/= :: PageTransitionDirection -> PageTransitionDirection -> Bool
== :: PageTransitionDirection -> PageTransitionDirection -> Bool
$c== :: PageTransitionDirection -> PageTransitionDirection -> Bool
Eq)

instance P.Enum PageTransitionDirection where
    fromEnum :: PageTransitionDirection -> Int
fromEnum PageTransitionDirection
PageTransitionDirectionInward = Int
0
    fromEnum PageTransitionDirection
PageTransitionDirectionOutward = Int
1
    fromEnum (AnotherPageTransitionDirection Int
k) = Int
k

    toEnum :: Int -> PageTransitionDirection
toEnum Int
0 = PageTransitionDirection
PageTransitionDirectionInward
    toEnum Int
1 = PageTransitionDirection
PageTransitionDirectionOutward
    toEnum Int
k = Int -> PageTransitionDirection
AnotherPageTransitionDirection Int
k

instance P.Ord PageTransitionDirection where
    compare :: PageTransitionDirection -> PageTransitionDirection -> Ordering
compare PageTransitionDirection
a PageTransitionDirection
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PageTransitionDirection -> Int
forall a. Enum a => a -> Int
P.fromEnum PageTransitionDirection
a) (PageTransitionDirection -> Int
forall a. Enum a => a -> Int
P.fromEnum PageTransitionDirection
b)

type instance O.ParentTypes PageTransitionDirection = '[]
instance O.HasParentTypes PageTransitionDirection

foreign import ccall "poppler_page_transition_direction_get_type" c_poppler_page_transition_direction_get_type :: 
    IO GType

instance B.Types.TypedObject PageTransitionDirection where
    glibType :: IO GType
glibType = IO GType
c_poppler_page_transition_direction_get_type

instance B.Types.BoxedEnum PageTransitionDirection

-- 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 (Int -> PageTransitionAlignment -> ShowS
[PageTransitionAlignment] -> ShowS
PageTransitionAlignment -> String
(Int -> PageTransitionAlignment -> ShowS)
-> (PageTransitionAlignment -> String)
-> ([PageTransitionAlignment] -> ShowS)
-> Show PageTransitionAlignment
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PageTransitionAlignment] -> ShowS
$cshowList :: [PageTransitionAlignment] -> ShowS
show :: PageTransitionAlignment -> String
$cshow :: PageTransitionAlignment -> String
showsPrec :: Int -> PageTransitionAlignment -> ShowS
$cshowsPrec :: Int -> PageTransitionAlignment -> ShowS
Show, PageTransitionAlignment -> PageTransitionAlignment -> Bool
(PageTransitionAlignment -> PageTransitionAlignment -> Bool)
-> (PageTransitionAlignment -> PageTransitionAlignment -> Bool)
-> Eq PageTransitionAlignment
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PageTransitionAlignment -> PageTransitionAlignment -> Bool
$c/= :: PageTransitionAlignment -> PageTransitionAlignment -> Bool
== :: PageTransitionAlignment -> PageTransitionAlignment -> Bool
$c== :: PageTransitionAlignment -> PageTransitionAlignment -> Bool
Eq)

instance P.Enum PageTransitionAlignment where
    fromEnum :: PageTransitionAlignment -> Int
fromEnum PageTransitionAlignment
PageTransitionAlignmentHorizontal = Int
0
    fromEnum PageTransitionAlignment
PageTransitionAlignmentVertical = Int
1
    fromEnum (AnotherPageTransitionAlignment Int
k) = Int
k

    toEnum :: Int -> PageTransitionAlignment
toEnum Int
0 = PageTransitionAlignment
PageTransitionAlignmentHorizontal
    toEnum Int
1 = PageTransitionAlignment
PageTransitionAlignmentVertical
    toEnum Int
k = Int -> PageTransitionAlignment
AnotherPageTransitionAlignment Int
k

instance P.Ord PageTransitionAlignment where
    compare :: PageTransitionAlignment -> PageTransitionAlignment -> Ordering
compare PageTransitionAlignment
a PageTransitionAlignment
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PageTransitionAlignment -> Int
forall a. Enum a => a -> Int
P.fromEnum PageTransitionAlignment
a) (PageTransitionAlignment -> Int
forall a. Enum a => a -> Int
P.fromEnum PageTransitionAlignment
b)

type instance O.ParentTypes PageTransitionAlignment = '[]
instance O.HasParentTypes PageTransitionAlignment

foreign import ccall "poppler_page_transition_alignment_get_type" c_poppler_page_transition_alignment_get_type :: 
    IO GType

instance B.Types.TypedObject PageTransitionAlignment where
    glibType :: IO GType
glibType = IO GType
c_poppler_page_transition_alignment_get_type

instance B.Types.BoxedEnum PageTransitionAlignment

-- 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 (Int -> PageMode -> ShowS
[PageMode] -> ShowS
PageMode -> String
(Int -> PageMode -> ShowS)
-> (PageMode -> String) -> ([PageMode] -> ShowS) -> Show PageMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PageMode] -> ShowS
$cshowList :: [PageMode] -> ShowS
show :: PageMode -> String
$cshow :: PageMode -> String
showsPrec :: Int -> PageMode -> ShowS
$cshowsPrec :: Int -> PageMode -> ShowS
Show, PageMode -> PageMode -> Bool
(PageMode -> PageMode -> Bool)
-> (PageMode -> PageMode -> Bool) -> Eq PageMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PageMode -> PageMode -> Bool
$c/= :: PageMode -> PageMode -> Bool
== :: PageMode -> PageMode -> Bool
$c== :: PageMode -> PageMode -> Bool
Eq)

instance P.Enum PageMode where
    fromEnum :: PageMode -> Int
fromEnum PageMode
PageModeUnset = Int
0
    fromEnum PageMode
PageModeNone = Int
1
    fromEnum PageMode
PageModeUseOutlines = Int
2
    fromEnum PageMode
PageModeUseThumbs = Int
3
    fromEnum PageMode
PageModeFullScreen = Int
4
    fromEnum PageMode
PageModeUseOc = Int
5
    fromEnum PageMode
PageModeUseAttachments = Int
6
    fromEnum (AnotherPageMode Int
k) = Int
k

    toEnum :: Int -> PageMode
toEnum Int
0 = PageMode
PageModeUnset
    toEnum Int
1 = PageMode
PageModeNone
    toEnum Int
2 = PageMode
PageModeUseOutlines
    toEnum Int
3 = PageMode
PageModeUseThumbs
    toEnum Int
4 = PageMode
PageModeFullScreen
    toEnum Int
5 = PageMode
PageModeUseOc
    toEnum Int
6 = PageMode
PageModeUseAttachments
    toEnum Int
k = Int -> PageMode
AnotherPageMode Int
k

instance P.Ord PageMode where
    compare :: PageMode -> PageMode -> Ordering
compare PageMode
a PageMode
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PageMode -> Int
forall a. Enum a => a -> Int
P.fromEnum PageMode
a) (PageMode -> Int
forall a. Enum a => a -> Int
P.fromEnum PageMode
b)

type instance O.ParentTypes PageMode = '[]
instance O.HasParentTypes PageMode

foreign import ccall "poppler_page_mode_get_type" c_poppler_page_mode_get_type :: 
    IO GType

instance B.Types.TypedObject PageMode where
    glibType :: IO GType
glibType = IO GType
c_poppler_page_mode_get_type

instance B.Types.BoxedEnum PageMode

-- 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 (Int -> PageLayout -> ShowS
[PageLayout] -> ShowS
PageLayout -> String
(Int -> PageLayout -> ShowS)
-> (PageLayout -> String)
-> ([PageLayout] -> ShowS)
-> Show PageLayout
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PageLayout] -> ShowS
$cshowList :: [PageLayout] -> ShowS
show :: PageLayout -> String
$cshow :: PageLayout -> String
showsPrec :: Int -> PageLayout -> ShowS
$cshowsPrec :: Int -> PageLayout -> ShowS
Show, PageLayout -> PageLayout -> Bool
(PageLayout -> PageLayout -> Bool)
-> (PageLayout -> PageLayout -> Bool) -> Eq PageLayout
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PageLayout -> PageLayout -> Bool
$c/= :: PageLayout -> PageLayout -> Bool
== :: PageLayout -> PageLayout -> Bool
$c== :: PageLayout -> PageLayout -> Bool
Eq)

instance P.Enum PageLayout where
    fromEnum :: PageLayout -> Int
fromEnum PageLayout
PageLayoutUnset = Int
0
    fromEnum PageLayout
PageLayoutSinglePage = Int
1
    fromEnum PageLayout
PageLayoutOneColumn = Int
2
    fromEnum PageLayout
PageLayoutTwoColumnLeft = Int
3
    fromEnum PageLayout
PageLayoutTwoColumnRight = Int
4
    fromEnum PageLayout
PageLayoutTwoPageLeft = Int
5
    fromEnum PageLayout
PageLayoutTwoPageRight = Int
6
    fromEnum (AnotherPageLayout Int
k) = Int
k

    toEnum :: Int -> PageLayout
toEnum Int
0 = PageLayout
PageLayoutUnset
    toEnum Int
1 = PageLayout
PageLayoutSinglePage
    toEnum Int
2 = PageLayout
PageLayoutOneColumn
    toEnum Int
3 = PageLayout
PageLayoutTwoColumnLeft
    toEnum Int
4 = PageLayout
PageLayoutTwoColumnRight
    toEnum Int
5 = PageLayout
PageLayoutTwoPageLeft
    toEnum Int
6 = PageLayout
PageLayoutTwoPageRight
    toEnum Int
k = Int -> PageLayout
AnotherPageLayout Int
k

instance P.Ord PageLayout where
    compare :: PageLayout -> PageLayout -> Ordering
compare PageLayout
a PageLayout
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PageLayout -> Int
forall a. Enum a => a -> Int
P.fromEnum PageLayout
a) (PageLayout -> Int
forall a. Enum a => a -> Int
P.fromEnum PageLayout
b)

type instance O.ParentTypes PageLayout = '[]
instance O.HasParentTypes PageLayout

foreign import ccall "poppler_page_layout_get_type" c_poppler_page_layout_get_type :: 
    IO GType

instance B.Types.TypedObject PageLayout where
    glibType :: IO GType
glibType = IO GType
c_poppler_page_layout_get_type

instance B.Types.BoxedEnum PageLayout

-- 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 (Int -> PDFSubtype -> ShowS
[PDFSubtype] -> ShowS
PDFSubtype -> String
(Int -> PDFSubtype -> ShowS)
-> (PDFSubtype -> String)
-> ([PDFSubtype] -> ShowS)
-> Show PDFSubtype
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PDFSubtype] -> ShowS
$cshowList :: [PDFSubtype] -> ShowS
show :: PDFSubtype -> String
$cshow :: PDFSubtype -> String
showsPrec :: Int -> PDFSubtype -> ShowS
$cshowsPrec :: Int -> PDFSubtype -> ShowS
Show, PDFSubtype -> PDFSubtype -> Bool
(PDFSubtype -> PDFSubtype -> Bool)
-> (PDFSubtype -> PDFSubtype -> Bool) -> Eq PDFSubtype
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PDFSubtype -> PDFSubtype -> Bool
$c/= :: PDFSubtype -> PDFSubtype -> Bool
== :: PDFSubtype -> PDFSubtype -> Bool
$c== :: PDFSubtype -> PDFSubtype -> Bool
Eq)

instance P.Enum PDFSubtype where
    fromEnum :: PDFSubtype -> Int
fromEnum PDFSubtype
PDFSubtypeUnset = Int
0
    fromEnum PDFSubtype
PDFSubtypePdfA = Int
1
    fromEnum PDFSubtype
PDFSubtypePdfE = Int
2
    fromEnum PDFSubtype
PDFSubtypePdfUa = Int
3
    fromEnum PDFSubtype
PDFSubtypePdfVt = Int
4
    fromEnum PDFSubtype
PDFSubtypePdfX = Int
5
    fromEnum PDFSubtype
PDFSubtypeNone = Int
6
    fromEnum (AnotherPDFSubtype Int
k) = Int
k

    toEnum :: Int -> PDFSubtype
toEnum Int
0 = PDFSubtype
PDFSubtypeUnset
    toEnum Int
1 = PDFSubtype
PDFSubtypePdfA
    toEnum Int
2 = PDFSubtype
PDFSubtypePdfE
    toEnum Int
3 = PDFSubtype
PDFSubtypePdfUa
    toEnum Int
4 = PDFSubtype
PDFSubtypePdfVt
    toEnum Int
5 = PDFSubtype
PDFSubtypePdfX
    toEnum Int
6 = PDFSubtype
PDFSubtypeNone
    toEnum Int
k = Int -> PDFSubtype
AnotherPDFSubtype Int
k

instance P.Ord PDFSubtype where
    compare :: PDFSubtype -> PDFSubtype -> Ordering
compare PDFSubtype
a PDFSubtype
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PDFSubtype -> Int
forall a. Enum a => a -> Int
P.fromEnum PDFSubtype
a) (PDFSubtype -> Int
forall a. Enum a => a -> Int
P.fromEnum PDFSubtype
b)

type instance O.ParentTypes PDFSubtype = '[]
instance O.HasParentTypes PDFSubtype

foreign import ccall "poppler_pdf_subtype_get_type" c_poppler_pdf_subtype_get_type :: 
    IO GType

instance B.Types.TypedObject PDFSubtype where
    glibType :: IO GType
glibType = IO GType
c_poppler_pdf_subtype_get_type

instance B.Types.BoxedEnum PDFSubtype

-- 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 (Int -> PDFPart -> ShowS
[PDFPart] -> ShowS
PDFPart -> String
(Int -> PDFPart -> ShowS)
-> (PDFPart -> String) -> ([PDFPart] -> ShowS) -> Show PDFPart
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PDFPart] -> ShowS
$cshowList :: [PDFPart] -> ShowS
show :: PDFPart -> String
$cshow :: PDFPart -> String
showsPrec :: Int -> PDFPart -> ShowS
$cshowsPrec :: Int -> PDFPart -> ShowS
Show, PDFPart -> PDFPart -> Bool
(PDFPart -> PDFPart -> Bool)
-> (PDFPart -> PDFPart -> Bool) -> Eq PDFPart
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PDFPart -> PDFPart -> Bool
$c/= :: PDFPart -> PDFPart -> Bool
== :: PDFPart -> PDFPart -> Bool
$c== :: PDFPart -> PDFPart -> Bool
Eq)

instance P.Enum PDFPart where
    fromEnum :: PDFPart -> Int
fromEnum PDFPart
PDFPartUnset = Int
0
    fromEnum PDFPart
PDFPart1 = Int
1
    fromEnum PDFPart
PDFPart2 = Int
2
    fromEnum PDFPart
PDFPart3 = Int
3
    fromEnum PDFPart
PDFPart4 = Int
4
    fromEnum PDFPart
PDFPart5 = Int
5
    fromEnum PDFPart
PDFPart6 = Int
6
    fromEnum PDFPart
PDFPart7 = Int
7
    fromEnum PDFPart
PDFPart8 = Int
8
    fromEnum PDFPart
PDFPartNone = Int
9
    fromEnum (AnotherPDFPart Int
k) = Int
k

    toEnum :: Int -> PDFPart
toEnum Int
0 = PDFPart
PDFPartUnset
    toEnum Int
1 = PDFPart
PDFPart1
    toEnum Int
2 = PDFPart
PDFPart2
    toEnum Int
3 = PDFPart
PDFPart3
    toEnum Int
4 = PDFPart
PDFPart4
    toEnum Int
5 = PDFPart
PDFPart5
    toEnum Int
6 = PDFPart
PDFPart6
    toEnum Int
7 = PDFPart
PDFPart7
    toEnum Int
8 = PDFPart
PDFPart8
    toEnum Int
9 = PDFPart
PDFPartNone
    toEnum Int
k = Int -> PDFPart
AnotherPDFPart Int
k

instance P.Ord PDFPart where
    compare :: PDFPart -> PDFPart -> Ordering
compare PDFPart
a PDFPart
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PDFPart -> Int
forall a. Enum a => a -> Int
P.fromEnum PDFPart
a) (PDFPart -> Int
forall a. Enum a => a -> Int
P.fromEnum PDFPart
b)

type instance O.ParentTypes PDFPart = '[]
instance O.HasParentTypes PDFPart

foreign import ccall "poppler_pdf_part_get_type" c_poppler_pdf_part_get_type :: 
    IO GType

instance B.Types.TypedObject PDFPart where
    glibType :: IO GType
glibType = IO GType
c_poppler_pdf_part_get_type

instance B.Types.BoxedEnum PDFPart

-- 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 (Int -> PDFConformance -> ShowS
[PDFConformance] -> ShowS
PDFConformance -> String
(Int -> PDFConformance -> ShowS)
-> (PDFConformance -> String)
-> ([PDFConformance] -> ShowS)
-> Show PDFConformance
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PDFConformance] -> ShowS
$cshowList :: [PDFConformance] -> ShowS
show :: PDFConformance -> String
$cshow :: PDFConformance -> String
showsPrec :: Int -> PDFConformance -> ShowS
$cshowsPrec :: Int -> PDFConformance -> ShowS
Show, PDFConformance -> PDFConformance -> Bool
(PDFConformance -> PDFConformance -> Bool)
-> (PDFConformance -> PDFConformance -> Bool) -> Eq PDFConformance
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PDFConformance -> PDFConformance -> Bool
$c/= :: PDFConformance -> PDFConformance -> Bool
== :: PDFConformance -> PDFConformance -> Bool
$c== :: PDFConformance -> PDFConformance -> Bool
Eq)

instance P.Enum PDFConformance where
    fromEnum :: PDFConformance -> Int
fromEnum PDFConformance
PDFConformanceUnset = Int
0
    fromEnum PDFConformance
PDFConformanceA = Int
1
    fromEnum PDFConformance
PDFConformanceB = Int
2
    fromEnum PDFConformance
PDFConformanceG = Int
3
    fromEnum PDFConformance
PDFConformanceN = Int
4
    fromEnum PDFConformance
PDFConformanceP = Int
5
    fromEnum PDFConformance
PDFConformancePg = Int
6
    fromEnum PDFConformance
PDFConformanceU = Int
7
    fromEnum PDFConformance
PDFConformanceNone = Int
8
    fromEnum (AnotherPDFConformance Int
k) = Int
k

    toEnum :: Int -> PDFConformance
toEnum Int
0 = PDFConformance
PDFConformanceUnset
    toEnum Int
1 = PDFConformance
PDFConformanceA
    toEnum Int
2 = PDFConformance
PDFConformanceB
    toEnum Int
3 = PDFConformance
PDFConformanceG
    toEnum Int
4 = PDFConformance
PDFConformanceN
    toEnum Int
5 = PDFConformance
PDFConformanceP
    toEnum Int
6 = PDFConformance
PDFConformancePg
    toEnum Int
7 = PDFConformance
PDFConformanceU
    toEnum Int
8 = PDFConformance
PDFConformanceNone
    toEnum Int
k = Int -> PDFConformance
AnotherPDFConformance Int
k

instance P.Ord PDFConformance where
    compare :: PDFConformance -> PDFConformance -> Ordering
compare PDFConformance
a PDFConformance
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PDFConformance -> Int
forall a. Enum a => a -> Int
P.fromEnum PDFConformance
a) (PDFConformance -> Int
forall a. Enum a => a -> Int
P.fromEnum PDFConformance
b)

type instance O.ParentTypes PDFConformance = '[]
instance O.HasParentTypes PDFConformance

foreign import ccall "poppler_pdf_conformance_get_type" c_poppler_pdf_conformance_get_type :: 
    IO GType

instance B.Types.TypedObject PDFConformance where
    glibType :: IO GType
glibType = IO GType
c_poppler_pdf_conformance_get_type

instance B.Types.BoxedEnum PDFConformance

-- 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 (Int -> MoviePlayMode -> ShowS
[MoviePlayMode] -> ShowS
MoviePlayMode -> String
(Int -> MoviePlayMode -> ShowS)
-> (MoviePlayMode -> String)
-> ([MoviePlayMode] -> ShowS)
-> Show MoviePlayMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MoviePlayMode] -> ShowS
$cshowList :: [MoviePlayMode] -> ShowS
show :: MoviePlayMode -> String
$cshow :: MoviePlayMode -> String
showsPrec :: Int -> MoviePlayMode -> ShowS
$cshowsPrec :: Int -> MoviePlayMode -> ShowS
Show, MoviePlayMode -> MoviePlayMode -> Bool
(MoviePlayMode -> MoviePlayMode -> Bool)
-> (MoviePlayMode -> MoviePlayMode -> Bool) -> Eq MoviePlayMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MoviePlayMode -> MoviePlayMode -> Bool
$c/= :: MoviePlayMode -> MoviePlayMode -> Bool
== :: MoviePlayMode -> MoviePlayMode -> Bool
$c== :: MoviePlayMode -> MoviePlayMode -> Bool
Eq)

instance P.Enum MoviePlayMode where
    fromEnum :: MoviePlayMode -> Int
fromEnum MoviePlayMode
MoviePlayModeOnce = Int
0
    fromEnum MoviePlayMode
MoviePlayModeOpen = Int
1
    fromEnum MoviePlayMode
MoviePlayModeRepeat = Int
2
    fromEnum MoviePlayMode
MoviePlayModePalindrome = Int
3
    fromEnum (AnotherMoviePlayMode Int
k) = Int
k

    toEnum :: Int -> MoviePlayMode
toEnum Int
0 = MoviePlayMode
MoviePlayModeOnce
    toEnum Int
1 = MoviePlayMode
MoviePlayModeOpen
    toEnum Int
2 = MoviePlayMode
MoviePlayModeRepeat
    toEnum Int
3 = MoviePlayMode
MoviePlayModePalindrome
    toEnum Int
k = Int -> MoviePlayMode
AnotherMoviePlayMode Int
k

instance P.Ord MoviePlayMode where
    compare :: MoviePlayMode -> MoviePlayMode -> Ordering
compare MoviePlayMode
a MoviePlayMode
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (MoviePlayMode -> Int
forall a. Enum a => a -> Int
P.fromEnum MoviePlayMode
a) (MoviePlayMode -> Int
forall a. Enum a => a -> Int
P.fromEnum MoviePlayMode
b)

type instance O.ParentTypes MoviePlayMode = '[]
instance O.HasParentTypes MoviePlayMode

foreign import ccall "poppler_movie_play_mode_get_type" c_poppler_movie_play_mode_get_type :: 
    IO GType

instance B.Types.TypedObject MoviePlayMode where
    glibType :: IO GType
glibType = IO GType
c_poppler_movie_play_mode_get_type

instance B.Types.BoxedEnum MoviePlayMode

-- 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 (Int -> FormTextType -> ShowS
[FormTextType] -> ShowS
FormTextType -> String
(Int -> FormTextType -> ShowS)
-> (FormTextType -> String)
-> ([FormTextType] -> ShowS)
-> Show FormTextType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FormTextType] -> ShowS
$cshowList :: [FormTextType] -> ShowS
show :: FormTextType -> String
$cshow :: FormTextType -> String
showsPrec :: Int -> FormTextType -> ShowS
$cshowsPrec :: Int -> FormTextType -> ShowS
Show, FormTextType -> FormTextType -> Bool
(FormTextType -> FormTextType -> Bool)
-> (FormTextType -> FormTextType -> Bool) -> Eq FormTextType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FormTextType -> FormTextType -> Bool
$c/= :: FormTextType -> FormTextType -> Bool
== :: FormTextType -> FormTextType -> Bool
$c== :: FormTextType -> FormTextType -> Bool
Eq)

instance P.Enum FormTextType where
    fromEnum :: FormTextType -> Int
fromEnum FormTextType
FormTextTypeNormal = Int
0
    fromEnum FormTextType
FormTextTypeMultiline = Int
1
    fromEnum FormTextType
FormTextTypeFileSelect = Int
2
    fromEnum (AnotherFormTextType Int
k) = Int
k

    toEnum :: Int -> FormTextType
toEnum Int
0 = FormTextType
FormTextTypeNormal
    toEnum Int
1 = FormTextType
FormTextTypeMultiline
    toEnum Int
2 = FormTextType
FormTextTypeFileSelect
    toEnum Int
k = Int -> FormTextType
AnotherFormTextType Int
k

instance P.Ord FormTextType where
    compare :: FormTextType -> FormTextType -> Ordering
compare FormTextType
a FormTextType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (FormTextType -> Int
forall a. Enum a => a -> Int
P.fromEnum FormTextType
a) (FormTextType -> Int
forall a. Enum a => a -> Int
P.fromEnum FormTextType
b)

type instance O.ParentTypes FormTextType = '[]
instance O.HasParentTypes FormTextType

foreign import ccall "poppler_form_text_type_get_type" c_poppler_form_text_type_get_type :: 
    IO GType

instance B.Types.TypedObject FormTextType where
    glibType :: IO GType
glibType = IO GType
c_poppler_form_text_type_get_type

instance B.Types.BoxedEnum FormTextType

-- 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 (Int -> FormFieldType -> ShowS
[FormFieldType] -> ShowS
FormFieldType -> String
(Int -> FormFieldType -> ShowS)
-> (FormFieldType -> String)
-> ([FormFieldType] -> ShowS)
-> Show FormFieldType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FormFieldType] -> ShowS
$cshowList :: [FormFieldType] -> ShowS
show :: FormFieldType -> String
$cshow :: FormFieldType -> String
showsPrec :: Int -> FormFieldType -> ShowS
$cshowsPrec :: Int -> FormFieldType -> ShowS
Show, FormFieldType -> FormFieldType -> Bool
(FormFieldType -> FormFieldType -> Bool)
-> (FormFieldType -> FormFieldType -> Bool) -> Eq FormFieldType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FormFieldType -> FormFieldType -> Bool
$c/= :: FormFieldType -> FormFieldType -> Bool
== :: FormFieldType -> FormFieldType -> Bool
$c== :: FormFieldType -> FormFieldType -> Bool
Eq)

instance P.Enum FormFieldType where
    fromEnum :: FormFieldType -> Int
fromEnum FormFieldType
FormFieldTypeUnknown = Int
0
    fromEnum FormFieldType
FormFieldTypeButton = Int
1
    fromEnum FormFieldType
FormFieldTypeText = Int
2
    fromEnum FormFieldType
FormFieldTypeChoice = Int
3
    fromEnum FormFieldType
FormFieldTypeSignature = Int
4
    fromEnum (AnotherFormFieldType Int
k) = Int
k

    toEnum :: Int -> FormFieldType
toEnum Int
0 = FormFieldType
FormFieldTypeUnknown
    toEnum Int
1 = FormFieldType
FormFieldTypeButton
    toEnum Int
2 = FormFieldType
FormFieldTypeText
    toEnum Int
3 = FormFieldType
FormFieldTypeChoice
    toEnum Int
4 = FormFieldType
FormFieldTypeSignature
    toEnum Int
k = Int -> FormFieldType
AnotherFormFieldType Int
k

instance P.Ord FormFieldType where
    compare :: FormFieldType -> FormFieldType -> Ordering
compare FormFieldType
a FormFieldType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (FormFieldType -> Int
forall a. Enum a => a -> Int
P.fromEnum FormFieldType
a) (FormFieldType -> Int
forall a. Enum a => a -> Int
P.fromEnum FormFieldType
b)

type instance O.ParentTypes FormFieldType = '[]
instance O.HasParentTypes FormFieldType

foreign import ccall "poppler_form_field_type_get_type" c_poppler_form_field_type_get_type :: 
    IO GType

instance B.Types.TypedObject FormFieldType where
    glibType :: IO GType
glibType = IO GType
c_poppler_form_field_type_get_type

instance B.Types.BoxedEnum FormFieldType

-- 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 (Int -> FormChoiceType -> ShowS
[FormChoiceType] -> ShowS
FormChoiceType -> String
(Int -> FormChoiceType -> ShowS)
-> (FormChoiceType -> String)
-> ([FormChoiceType] -> ShowS)
-> Show FormChoiceType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FormChoiceType] -> ShowS
$cshowList :: [FormChoiceType] -> ShowS
show :: FormChoiceType -> String
$cshow :: FormChoiceType -> String
showsPrec :: Int -> FormChoiceType -> ShowS
$cshowsPrec :: Int -> FormChoiceType -> ShowS
Show, FormChoiceType -> FormChoiceType -> Bool
(FormChoiceType -> FormChoiceType -> Bool)
-> (FormChoiceType -> FormChoiceType -> Bool) -> Eq FormChoiceType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FormChoiceType -> FormChoiceType -> Bool
$c/= :: FormChoiceType -> FormChoiceType -> Bool
== :: FormChoiceType -> FormChoiceType -> Bool
$c== :: FormChoiceType -> FormChoiceType -> Bool
Eq)

instance P.Enum FormChoiceType where
    fromEnum :: FormChoiceType -> Int
fromEnum FormChoiceType
FormChoiceTypeCombo = Int
0
    fromEnum FormChoiceType
FormChoiceTypeList = Int
1
    fromEnum (AnotherFormChoiceType Int
k) = Int
k

    toEnum :: Int -> FormChoiceType
toEnum Int
0 = FormChoiceType
FormChoiceTypeCombo
    toEnum Int
1 = FormChoiceType
FormChoiceTypeList
    toEnum Int
k = Int -> FormChoiceType
AnotherFormChoiceType Int
k

instance P.Ord FormChoiceType where
    compare :: FormChoiceType -> FormChoiceType -> Ordering
compare FormChoiceType
a FormChoiceType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (FormChoiceType -> Int
forall a. Enum a => a -> Int
P.fromEnum FormChoiceType
a) (FormChoiceType -> Int
forall a. Enum a => a -> Int
P.fromEnum FormChoiceType
b)

type instance O.ParentTypes FormChoiceType = '[]
instance O.HasParentTypes FormChoiceType

foreign import ccall "poppler_form_choice_type_get_type" c_poppler_form_choice_type_get_type :: 
    IO GType

instance B.Types.TypedObject FormChoiceType where
    glibType :: IO GType
glibType = IO GType
c_poppler_form_choice_type_get_type

instance B.Types.BoxedEnum FormChoiceType

-- 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 (Int -> FormButtonType -> ShowS
[FormButtonType] -> ShowS
FormButtonType -> String
(Int -> FormButtonType -> ShowS)
-> (FormButtonType -> String)
-> ([FormButtonType] -> ShowS)
-> Show FormButtonType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FormButtonType] -> ShowS
$cshowList :: [FormButtonType] -> ShowS
show :: FormButtonType -> String
$cshow :: FormButtonType -> String
showsPrec :: Int -> FormButtonType -> ShowS
$cshowsPrec :: Int -> FormButtonType -> ShowS
Show, FormButtonType -> FormButtonType -> Bool
(FormButtonType -> FormButtonType -> Bool)
-> (FormButtonType -> FormButtonType -> Bool) -> Eq FormButtonType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FormButtonType -> FormButtonType -> Bool
$c/= :: FormButtonType -> FormButtonType -> Bool
== :: FormButtonType -> FormButtonType -> Bool
$c== :: FormButtonType -> FormButtonType -> Bool
Eq)

instance P.Enum FormButtonType where
    fromEnum :: FormButtonType -> Int
fromEnum FormButtonType
FormButtonTypePush = Int
0
    fromEnum FormButtonType
FormButtonTypeCheck = Int
1
    fromEnum FormButtonType
FormButtonTypeRadio = Int
2
    fromEnum (AnotherFormButtonType Int
k) = Int
k

    toEnum :: Int -> FormButtonType
toEnum Int
0 = FormButtonType
FormButtonTypePush
    toEnum Int
1 = FormButtonType
FormButtonTypeCheck
    toEnum Int
2 = FormButtonType
FormButtonTypeRadio
    toEnum Int
k = Int -> FormButtonType
AnotherFormButtonType Int
k

instance P.Ord FormButtonType where
    compare :: FormButtonType -> FormButtonType -> Ordering
compare FormButtonType
a FormButtonType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (FormButtonType -> Int
forall a. Enum a => a -> Int
P.fromEnum FormButtonType
a) (FormButtonType -> Int
forall a. Enum a => a -> Int
P.fromEnum FormButtonType
b)

type instance O.ParentTypes FormButtonType = '[]
instance O.HasParentTypes FormButtonType

foreign import ccall "poppler_form_button_type_get_type" c_poppler_form_button_type_get_type :: 
    IO GType

instance B.Types.TypedObject FormButtonType where
    glibType :: IO GType
glibType = IO GType
c_poppler_form_button_type_get_type

instance B.Types.BoxedEnum FormButtonType

-- 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 (Int -> FontType -> ShowS
[FontType] -> ShowS
FontType -> String
(Int -> FontType -> ShowS)
-> (FontType -> String) -> ([FontType] -> ShowS) -> Show FontType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FontType] -> ShowS
$cshowList :: [FontType] -> ShowS
show :: FontType -> String
$cshow :: FontType -> String
showsPrec :: Int -> FontType -> ShowS
$cshowsPrec :: Int -> FontType -> ShowS
Show, FontType -> FontType -> Bool
(FontType -> FontType -> Bool)
-> (FontType -> FontType -> Bool) -> Eq FontType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FontType -> FontType -> Bool
$c/= :: FontType -> FontType -> Bool
== :: FontType -> FontType -> Bool
$c== :: FontType -> FontType -> Bool
Eq)

instance P.Enum FontType where
    fromEnum :: FontType -> Int
fromEnum FontType
FontTypeUnknown = Int
0
    fromEnum FontType
FontTypeType1 = Int
1
    fromEnum FontType
FontTypeType1c = Int
2
    fromEnum FontType
FontTypeType1cot = Int
3
    fromEnum FontType
FontTypeType3 = Int
4
    fromEnum FontType
FontTypeTruetype = Int
5
    fromEnum FontType
FontTypeTruetypeot = Int
6
    fromEnum FontType
FontTypeCidType0 = Int
7
    fromEnum FontType
FontTypeCidType0c = Int
8
    fromEnum FontType
FontTypeCidType0cot = Int
9
    fromEnum FontType
FontTypeCidType2 = Int
10
    fromEnum FontType
FontTypeCidType2ot = Int
11
    fromEnum (AnotherFontType Int
k) = Int
k

    toEnum :: Int -> FontType
toEnum Int
0 = FontType
FontTypeUnknown
    toEnum Int
1 = FontType
FontTypeType1
    toEnum Int
2 = FontType
FontTypeType1c
    toEnum Int
3 = FontType
FontTypeType1cot
    toEnum Int
4 = FontType
FontTypeType3
    toEnum Int
5 = FontType
FontTypeTruetype
    toEnum Int
6 = FontType
FontTypeTruetypeot
    toEnum Int
7 = FontType
FontTypeCidType0
    toEnum Int
8 = FontType
FontTypeCidType0c
    toEnum Int
9 = FontType
FontTypeCidType0cot
    toEnum Int
10 = FontType
FontTypeCidType2
    toEnum Int
11 = FontType
FontTypeCidType2ot
    toEnum Int
k = Int -> FontType
AnotherFontType Int
k

instance P.Ord FontType where
    compare :: FontType -> FontType -> Ordering
compare FontType
a FontType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (FontType -> Int
forall a. Enum a => a -> Int
P.fromEnum FontType
a) (FontType -> Int
forall a. Enum a => a -> Int
P.fromEnum FontType
b)

type instance O.ParentTypes FontType = '[]
instance O.HasParentTypes FontType

foreign import ccall "poppler_font_type_get_type" c_poppler_font_type_get_type :: 
    IO GType

instance B.Types.TypedObject FontType where
    glibType :: IO GType
glibType = IO GType
c_poppler_font_type_get_type

instance B.Types.BoxedEnum FontType

-- Enum Error
-- | Error codes returned by t'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 (Int -> Error -> ShowS
[Error] -> ShowS
Error -> String
(Int -> Error -> ShowS)
-> (Error -> String) -> ([Error] -> ShowS) -> Show Error
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Error] -> ShowS
$cshowList :: [Error] -> ShowS
show :: Error -> String
$cshow :: Error -> String
showsPrec :: Int -> Error -> ShowS
$cshowsPrec :: Int -> Error -> ShowS
Show, Error -> Error -> Bool
(Error -> Error -> Bool) -> (Error -> Error -> Bool) -> Eq Error
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Error -> Error -> Bool
$c/= :: Error -> Error -> Bool
== :: Error -> Error -> Bool
$c== :: Error -> Error -> Bool
Eq)

instance P.Enum Error where
    fromEnum :: Error -> Int
fromEnum Error
ErrorInvalid = Int
0
    fromEnum Error
ErrorEncrypted = Int
1
    fromEnum Error
ErrorOpenFile = Int
2
    fromEnum Error
ErrorBadCatalog = Int
3
    fromEnum Error
ErrorDamaged = Int
4
    fromEnum (AnotherError Int
k) = Int
k

    toEnum :: Int -> Error
toEnum Int
0 = Error
ErrorInvalid
    toEnum Int
1 = Error
ErrorEncrypted
    toEnum Int
2 = Error
ErrorOpenFile
    toEnum Int
3 = Error
ErrorBadCatalog
    toEnum Int
4 = Error
ErrorDamaged
    toEnum Int
k = Int -> Error
AnotherError Int
k

instance P.Ord Error where
    compare :: Error -> Error -> Ordering
compare Error
a Error
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (Error -> Int
forall a. Enum a => a -> Int
P.fromEnum Error
a) (Error -> Int
forall a. Enum a => a -> Int
P.fromEnum Error
b)

instance GErrorClass Error where
    gerrorClassDomain :: Error -> Text
gerrorClassDomain Error
_ = Text
"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 :: forall a. IO a -> (Error -> Text -> IO a) -> IO a
catchError = IO a -> (Error -> Text -> IO a) -> IO a
forall err a.
GErrorClass err =>
IO a -> (err -> Text -> IO a) -> IO a
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 :: forall a. (Error -> Text -> IO a) -> IO a -> IO a
handleError = (Error -> Text -> IO a) -> IO a -> IO a
forall err a.
GErrorClass err =>
(err -> Text -> IO a) -> IO a -> IO a
handleGErrorJustDomain

type instance O.ParentTypes Error = '[]
instance O.HasParentTypes Error

foreign import ccall "poppler_error_get_type" c_poppler_error_get_type :: 
    IO GType

instance B.Types.TypedObject Error where
    glibType :: IO GType
glibType = IO GType
c_poppler_error_get_type

instance B.Types.BoxedEnum Error

-- 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 (Int -> DestType -> ShowS
[DestType] -> ShowS
DestType -> String
(Int -> DestType -> ShowS)
-> (DestType -> String) -> ([DestType] -> ShowS) -> Show DestType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DestType] -> ShowS
$cshowList :: [DestType] -> ShowS
show :: DestType -> String
$cshow :: DestType -> String
showsPrec :: Int -> DestType -> ShowS
$cshowsPrec :: Int -> DestType -> ShowS
Show, DestType -> DestType -> Bool
(DestType -> DestType -> Bool)
-> (DestType -> DestType -> Bool) -> Eq DestType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DestType -> DestType -> Bool
$c/= :: DestType -> DestType -> Bool
== :: DestType -> DestType -> Bool
$c== :: DestType -> DestType -> Bool
Eq)

instance P.Enum DestType where
    fromEnum :: DestType -> Int
fromEnum DestType
DestTypeUnknown = Int
0
    fromEnum DestType
DestTypeXyz = Int
1
    fromEnum DestType
DestTypeFit = Int
2
    fromEnum DestType
DestTypeFith = Int
3
    fromEnum DestType
DestTypeFitv = Int
4
    fromEnum DestType
DestTypeFitr = Int
5
    fromEnum DestType
DestTypeFitb = Int
6
    fromEnum DestType
DestTypeFitbh = Int
7
    fromEnum DestType
DestTypeFitbv = Int
8
    fromEnum DestType
DestTypeNamed = Int
9
    fromEnum (AnotherDestType Int
k) = Int
k

    toEnum :: Int -> DestType
toEnum Int
0 = DestType
DestTypeUnknown
    toEnum Int
1 = DestType
DestTypeXyz
    toEnum Int
2 = DestType
DestTypeFit
    toEnum Int
3 = DestType
DestTypeFith
    toEnum Int
4 = DestType
DestTypeFitv
    toEnum Int
5 = DestType
DestTypeFitr
    toEnum Int
6 = DestType
DestTypeFitb
    toEnum Int
7 = DestType
DestTypeFitbh
    toEnum Int
8 = DestType
DestTypeFitbv
    toEnum Int
9 = DestType
DestTypeNamed
    toEnum Int
k = Int -> DestType
AnotherDestType Int
k

instance P.Ord DestType where
    compare :: DestType -> DestType -> Ordering
compare DestType
a DestType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (DestType -> Int
forall a. Enum a => a -> Int
P.fromEnum DestType
a) (DestType -> Int
forall a. Enum a => a -> Int
P.fromEnum DestType
b)

type instance O.ParentTypes DestType = '[]
instance O.HasParentTypes DestType

foreign import ccall "poppler_dest_type_get_type" c_poppler_dest_type_get_type :: 
    IO GType

instance B.Types.TypedObject DestType where
    glibType :: IO GType
glibType = IO GType
c_poppler_dest_type_get_type

instance B.Types.BoxedEnum DestType

-- 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 (Int -> Backend -> ShowS
[Backend] -> ShowS
Backend -> String
(Int -> Backend -> ShowS)
-> (Backend -> String) -> ([Backend] -> ShowS) -> Show Backend
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Backend] -> ShowS
$cshowList :: [Backend] -> ShowS
show :: Backend -> String
$cshow :: Backend -> String
showsPrec :: Int -> Backend -> ShowS
$cshowsPrec :: Int -> Backend -> ShowS
Show, Backend -> Backend -> Bool
(Backend -> Backend -> Bool)
-> (Backend -> Backend -> Bool) -> Eq Backend
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Backend -> Backend -> Bool
$c/= :: Backend -> Backend -> Bool
== :: Backend -> Backend -> Bool
$c== :: Backend -> Backend -> Bool
Eq)

instance P.Enum Backend where
    fromEnum :: Backend -> Int
fromEnum Backend
BackendUnknown = Int
0
    fromEnum Backend
BackendSplash = Int
1
    fromEnum Backend
BackendCairo = Int
2
    fromEnum (AnotherBackend Int
k) = Int
k

    toEnum :: Int -> Backend
toEnum Int
0 = Backend
BackendUnknown
    toEnum Int
1 = Backend
BackendSplash
    toEnum Int
2 = Backend
BackendCairo
    toEnum Int
k = Int -> Backend
AnotherBackend Int
k

instance P.Ord Backend where
    compare :: Backend -> Backend -> Ordering
compare Backend
a Backend
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (Backend -> Int
forall a. Enum a => a -> Int
P.fromEnum Backend
a) (Backend -> Int
forall a. Enum a => a -> Int
P.fromEnum Backend
b)

type instance O.ParentTypes Backend = '[]
instance O.HasParentTypes Backend

foreign import ccall "poppler_backend_get_type" c_poppler_backend_get_type :: 
    IO GType

instance B.Types.TypedObject Backend where
    glibType :: IO GType
glibType = IO GType
c_poppler_backend_get_type

instance B.Types.BoxedEnum Backend

-- 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 (Int -> AnnotType -> ShowS
[AnnotType] -> ShowS
AnnotType -> String
(Int -> AnnotType -> ShowS)
-> (AnnotType -> String)
-> ([AnnotType] -> ShowS)
-> Show AnnotType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AnnotType] -> ShowS
$cshowList :: [AnnotType] -> ShowS
show :: AnnotType -> String
$cshow :: AnnotType -> String
showsPrec :: Int -> AnnotType -> ShowS
$cshowsPrec :: Int -> AnnotType -> ShowS
Show, AnnotType -> AnnotType -> Bool
(AnnotType -> AnnotType -> Bool)
-> (AnnotType -> AnnotType -> Bool) -> Eq AnnotType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AnnotType -> AnnotType -> Bool
$c/= :: AnnotType -> AnnotType -> Bool
== :: AnnotType -> AnnotType -> Bool
$c== :: AnnotType -> AnnotType -> Bool
Eq)

instance P.Enum AnnotType where
    fromEnum :: AnnotType -> Int
fromEnum AnnotType
AnnotTypeUnknown = Int
0
    fromEnum AnnotType
AnnotTypeText = Int
1
    fromEnum AnnotType
AnnotTypeLink = Int
2
    fromEnum AnnotType
AnnotTypeFreeText = Int
3
    fromEnum AnnotType
AnnotTypeLine = Int
4
    fromEnum AnnotType
AnnotTypeSquare = Int
5
    fromEnum AnnotType
AnnotTypeCircle = Int
6
    fromEnum AnnotType
AnnotTypePolygon = Int
7
    fromEnum AnnotType
AnnotTypePolyLine = Int
8
    fromEnum AnnotType
AnnotTypeHighlight = Int
9
    fromEnum AnnotType
AnnotTypeUnderline = Int
10
    fromEnum AnnotType
AnnotTypeSquiggly = Int
11
    fromEnum AnnotType
AnnotTypeStrikeOut = Int
12
    fromEnum AnnotType
AnnotTypeStamp = Int
13
    fromEnum AnnotType
AnnotTypeCaret = Int
14
    fromEnum AnnotType
AnnotTypeInk = Int
15
    fromEnum AnnotType
AnnotTypePopup = Int
16
    fromEnum AnnotType
AnnotTypeFileAttachment = Int
17
    fromEnum AnnotType
AnnotTypeSound = Int
18
    fromEnum AnnotType
AnnotTypeMovie = Int
19
    fromEnum AnnotType
AnnotTypeWidget = Int
20
    fromEnum AnnotType
AnnotTypeScreen = Int
21
    fromEnum AnnotType
AnnotTypePrinterMark = Int
22
    fromEnum AnnotType
AnnotTypeTrapNet = Int
23
    fromEnum AnnotType
AnnotTypeWatermark = Int
24
    fromEnum AnnotType
AnnotType3d = Int
25
    fromEnum (AnotherAnnotType Int
k) = Int
k

    toEnum :: Int -> AnnotType
toEnum Int
0 = AnnotType
AnnotTypeUnknown
    toEnum Int
1 = AnnotType
AnnotTypeText
    toEnum Int
2 = AnnotType
AnnotTypeLink
    toEnum Int
3 = AnnotType
AnnotTypeFreeText
    toEnum Int
4 = AnnotType
AnnotTypeLine
    toEnum Int
5 = AnnotType
AnnotTypeSquare
    toEnum Int
6 = AnnotType
AnnotTypeCircle
    toEnum Int
7 = AnnotType
AnnotTypePolygon
    toEnum Int
8 = AnnotType
AnnotTypePolyLine
    toEnum Int
9 = AnnotType
AnnotTypeHighlight
    toEnum Int
10 = AnnotType
AnnotTypeUnderline
    toEnum Int
11 = AnnotType
AnnotTypeSquiggly
    toEnum Int
12 = AnnotType
AnnotTypeStrikeOut
    toEnum Int
13 = AnnotType
AnnotTypeStamp
    toEnum Int
14 = AnnotType
AnnotTypeCaret
    toEnum Int
15 = AnnotType
AnnotTypeInk
    toEnum Int
16 = AnnotType
AnnotTypePopup
    toEnum Int
17 = AnnotType
AnnotTypeFileAttachment
    toEnum Int
18 = AnnotType
AnnotTypeSound
    toEnum Int
19 = AnnotType
AnnotTypeMovie
    toEnum Int
20 = AnnotType
AnnotTypeWidget
    toEnum Int
21 = AnnotType
AnnotTypeScreen
    toEnum Int
22 = AnnotType
AnnotTypePrinterMark
    toEnum Int
23 = AnnotType
AnnotTypeTrapNet
    toEnum Int
24 = AnnotType
AnnotTypeWatermark
    toEnum Int
25 = AnnotType
AnnotType3d
    toEnum Int
k = Int -> AnnotType
AnotherAnnotType Int
k

instance P.Ord AnnotType where
    compare :: AnnotType -> AnnotType -> Ordering
compare AnnotType
a AnnotType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (AnnotType -> Int
forall a. Enum a => a -> Int
P.fromEnum AnnotType
a) (AnnotType -> Int
forall a. Enum a => a -> Int
P.fromEnum AnnotType
b)

type instance O.ParentTypes AnnotType = '[]
instance O.HasParentTypes AnnotType

foreign import ccall "poppler_annot_type_get_type" c_poppler_annot_type_get_type :: 
    IO GType

instance B.Types.TypedObject AnnotType where
    glibType :: IO GType
glibType = IO GType
c_poppler_annot_type_get_type

instance B.Types.BoxedEnum AnnotType

-- 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 (Int -> AnnotTextState -> ShowS
[AnnotTextState] -> ShowS
AnnotTextState -> String
(Int -> AnnotTextState -> ShowS)
-> (AnnotTextState -> String)
-> ([AnnotTextState] -> ShowS)
-> Show AnnotTextState
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AnnotTextState] -> ShowS
$cshowList :: [AnnotTextState] -> ShowS
show :: AnnotTextState -> String
$cshow :: AnnotTextState -> String
showsPrec :: Int -> AnnotTextState -> ShowS
$cshowsPrec :: Int -> AnnotTextState -> ShowS
Show, AnnotTextState -> AnnotTextState -> Bool
(AnnotTextState -> AnnotTextState -> Bool)
-> (AnnotTextState -> AnnotTextState -> Bool) -> Eq AnnotTextState
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AnnotTextState -> AnnotTextState -> Bool
$c/= :: AnnotTextState -> AnnotTextState -> Bool
== :: AnnotTextState -> AnnotTextState -> Bool
$c== :: AnnotTextState -> AnnotTextState -> Bool
Eq)

instance P.Enum AnnotTextState where
    fromEnum :: AnnotTextState -> Int
fromEnum AnnotTextState
AnnotTextStateMarked = Int
0
    fromEnum AnnotTextState
AnnotTextStateUnmarked = Int
1
    fromEnum AnnotTextState
AnnotTextStateAccepted = Int
2
    fromEnum AnnotTextState
AnnotTextStateRejected = Int
3
    fromEnum AnnotTextState
AnnotTextStateCancelled = Int
4
    fromEnum AnnotTextState
AnnotTextStateCompleted = Int
5
    fromEnum AnnotTextState
AnnotTextStateNone = Int
6
    fromEnum AnnotTextState
AnnotTextStateUnknown = Int
7
    fromEnum (AnotherAnnotTextState Int
k) = Int
k

    toEnum :: Int -> AnnotTextState
toEnum Int
0 = AnnotTextState
AnnotTextStateMarked
    toEnum Int
1 = AnnotTextState
AnnotTextStateUnmarked
    toEnum Int
2 = AnnotTextState
AnnotTextStateAccepted
    toEnum Int
3 = AnnotTextState
AnnotTextStateRejected
    toEnum Int
4 = AnnotTextState
AnnotTextStateCancelled
    toEnum Int
5 = AnnotTextState
AnnotTextStateCompleted
    toEnum Int
6 = AnnotTextState
AnnotTextStateNone
    toEnum Int
7 = AnnotTextState
AnnotTextStateUnknown
    toEnum Int
k = Int -> AnnotTextState
AnotherAnnotTextState Int
k

instance P.Ord AnnotTextState where
    compare :: AnnotTextState -> AnnotTextState -> Ordering
compare AnnotTextState
a AnnotTextState
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (AnnotTextState -> Int
forall a. Enum a => a -> Int
P.fromEnum AnnotTextState
a) (AnnotTextState -> Int
forall a. Enum a => a -> Int
P.fromEnum AnnotTextState
b)

type instance O.ParentTypes AnnotTextState = '[]
instance O.HasParentTypes AnnotTextState

foreign import ccall "poppler_annot_text_state_get_type" c_poppler_annot_text_state_get_type :: 
    IO GType

instance B.Types.TypedObject AnnotTextState where
    glibType :: IO GType
glibType = IO GType
c_poppler_annot_text_state_get_type

instance B.Types.BoxedEnum AnnotTextState

-- 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 (Int -> AnnotMarkupReplyType -> ShowS
[AnnotMarkupReplyType] -> ShowS
AnnotMarkupReplyType -> String
(Int -> AnnotMarkupReplyType -> ShowS)
-> (AnnotMarkupReplyType -> String)
-> ([AnnotMarkupReplyType] -> ShowS)
-> Show AnnotMarkupReplyType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AnnotMarkupReplyType] -> ShowS
$cshowList :: [AnnotMarkupReplyType] -> ShowS
show :: AnnotMarkupReplyType -> String
$cshow :: AnnotMarkupReplyType -> String
showsPrec :: Int -> AnnotMarkupReplyType -> ShowS
$cshowsPrec :: Int -> AnnotMarkupReplyType -> ShowS
Show, AnnotMarkupReplyType -> AnnotMarkupReplyType -> Bool
(AnnotMarkupReplyType -> AnnotMarkupReplyType -> Bool)
-> (AnnotMarkupReplyType -> AnnotMarkupReplyType -> Bool)
-> Eq AnnotMarkupReplyType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AnnotMarkupReplyType -> AnnotMarkupReplyType -> Bool
$c/= :: AnnotMarkupReplyType -> AnnotMarkupReplyType -> Bool
== :: AnnotMarkupReplyType -> AnnotMarkupReplyType -> Bool
$c== :: AnnotMarkupReplyType -> AnnotMarkupReplyType -> Bool
Eq)

instance P.Enum AnnotMarkupReplyType where
    fromEnum :: AnnotMarkupReplyType -> Int
fromEnum AnnotMarkupReplyType
AnnotMarkupReplyTypeR = Int
0
    fromEnum AnnotMarkupReplyType
AnnotMarkupReplyTypeGroup = Int
1
    fromEnum (AnotherAnnotMarkupReplyType Int
k) = Int
k

    toEnum :: Int -> AnnotMarkupReplyType
toEnum Int
0 = AnnotMarkupReplyType
AnnotMarkupReplyTypeR
    toEnum Int
1 = AnnotMarkupReplyType
AnnotMarkupReplyTypeGroup
    toEnum Int
k = Int -> AnnotMarkupReplyType
AnotherAnnotMarkupReplyType Int
k

instance P.Ord AnnotMarkupReplyType where
    compare :: AnnotMarkupReplyType -> AnnotMarkupReplyType -> Ordering
compare AnnotMarkupReplyType
a AnnotMarkupReplyType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (AnnotMarkupReplyType -> Int
forall a. Enum a => a -> Int
P.fromEnum AnnotMarkupReplyType
a) (AnnotMarkupReplyType -> Int
forall a. Enum a => a -> Int
P.fromEnum AnnotMarkupReplyType
b)

type instance O.ParentTypes AnnotMarkupReplyType = '[]
instance O.HasParentTypes AnnotMarkupReplyType

foreign import ccall "poppler_annot_markup_reply_type_get_type" c_poppler_annot_markup_reply_type_get_type :: 
    IO GType

instance B.Types.TypedObject AnnotMarkupReplyType where
    glibType :: IO GType
glibType = IO GType
c_poppler_annot_markup_reply_type_get_type

instance B.Types.BoxedEnum AnnotMarkupReplyType

-- 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 (Int -> AnnotFreeTextQuadding -> ShowS
[AnnotFreeTextQuadding] -> ShowS
AnnotFreeTextQuadding -> String
(Int -> AnnotFreeTextQuadding -> ShowS)
-> (AnnotFreeTextQuadding -> String)
-> ([AnnotFreeTextQuadding] -> ShowS)
-> Show AnnotFreeTextQuadding
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AnnotFreeTextQuadding] -> ShowS
$cshowList :: [AnnotFreeTextQuadding] -> ShowS
show :: AnnotFreeTextQuadding -> String
$cshow :: AnnotFreeTextQuadding -> String
showsPrec :: Int -> AnnotFreeTextQuadding -> ShowS
$cshowsPrec :: Int -> AnnotFreeTextQuadding -> ShowS
Show, AnnotFreeTextQuadding -> AnnotFreeTextQuadding -> Bool
(AnnotFreeTextQuadding -> AnnotFreeTextQuadding -> Bool)
-> (AnnotFreeTextQuadding -> AnnotFreeTextQuadding -> Bool)
-> Eq AnnotFreeTextQuadding
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AnnotFreeTextQuadding -> AnnotFreeTextQuadding -> Bool
$c/= :: AnnotFreeTextQuadding -> AnnotFreeTextQuadding -> Bool
== :: AnnotFreeTextQuadding -> AnnotFreeTextQuadding -> Bool
$c== :: AnnotFreeTextQuadding -> AnnotFreeTextQuadding -> Bool
Eq)

instance P.Enum AnnotFreeTextQuadding where
    fromEnum :: AnnotFreeTextQuadding -> Int
fromEnum AnnotFreeTextQuadding
AnnotFreeTextQuaddingLeftJustified = Int
0
    fromEnum AnnotFreeTextQuadding
AnnotFreeTextQuaddingCentered = Int
1
    fromEnum AnnotFreeTextQuadding
AnnotFreeTextQuaddingRightJustified = Int
2
    fromEnum (AnotherAnnotFreeTextQuadding Int
k) = Int
k

    toEnum :: Int -> AnnotFreeTextQuadding
toEnum Int
0 = AnnotFreeTextQuadding
AnnotFreeTextQuaddingLeftJustified
    toEnum Int
1 = AnnotFreeTextQuadding
AnnotFreeTextQuaddingCentered
    toEnum Int
2 = AnnotFreeTextQuadding
AnnotFreeTextQuaddingRightJustified
    toEnum Int
k = Int -> AnnotFreeTextQuadding
AnotherAnnotFreeTextQuadding Int
k

instance P.Ord AnnotFreeTextQuadding where
    compare :: AnnotFreeTextQuadding -> AnnotFreeTextQuadding -> Ordering
compare AnnotFreeTextQuadding
a AnnotFreeTextQuadding
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (AnnotFreeTextQuadding -> Int
forall a. Enum a => a -> Int
P.fromEnum AnnotFreeTextQuadding
a) (AnnotFreeTextQuadding -> Int
forall a. Enum a => a -> Int
P.fromEnum AnnotFreeTextQuadding
b)

type instance O.ParentTypes AnnotFreeTextQuadding = '[]
instance O.HasParentTypes AnnotFreeTextQuadding

foreign import ccall "poppler_annot_free_text_quadding_get_type" c_poppler_annot_free_text_quadding_get_type :: 
    IO GType

instance B.Types.TypedObject AnnotFreeTextQuadding where
    glibType :: IO GType
glibType = IO GType
c_poppler_annot_free_text_quadding_get_type

instance B.Types.BoxedEnum AnnotFreeTextQuadding

-- 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 (Int -> AnnotExternalDataType -> ShowS
[AnnotExternalDataType] -> ShowS
AnnotExternalDataType -> String
(Int -> AnnotExternalDataType -> ShowS)
-> (AnnotExternalDataType -> String)
-> ([AnnotExternalDataType] -> ShowS)
-> Show AnnotExternalDataType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AnnotExternalDataType] -> ShowS
$cshowList :: [AnnotExternalDataType] -> ShowS
show :: AnnotExternalDataType -> String
$cshow :: AnnotExternalDataType -> String
showsPrec :: Int -> AnnotExternalDataType -> ShowS
$cshowsPrec :: Int -> AnnotExternalDataType -> ShowS
Show, AnnotExternalDataType -> AnnotExternalDataType -> Bool
(AnnotExternalDataType -> AnnotExternalDataType -> Bool)
-> (AnnotExternalDataType -> AnnotExternalDataType -> Bool)
-> Eq AnnotExternalDataType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AnnotExternalDataType -> AnnotExternalDataType -> Bool
$c/= :: AnnotExternalDataType -> AnnotExternalDataType -> Bool
== :: AnnotExternalDataType -> AnnotExternalDataType -> Bool
$c== :: AnnotExternalDataType -> AnnotExternalDataType -> Bool
Eq)

instance P.Enum AnnotExternalDataType where
    fromEnum :: AnnotExternalDataType -> Int
fromEnum AnnotExternalDataType
AnnotExternalDataType3d = Int
0
    fromEnum AnnotExternalDataType
AnnotExternalDataTypeUnknown = Int
1
    fromEnum (AnotherAnnotExternalDataType Int
k) = Int
k

    toEnum :: Int -> AnnotExternalDataType
toEnum Int
0 = AnnotExternalDataType
AnnotExternalDataType3d
    toEnum Int
1 = AnnotExternalDataType
AnnotExternalDataTypeUnknown
    toEnum Int
k = Int -> AnnotExternalDataType
AnotherAnnotExternalDataType Int
k

instance P.Ord AnnotExternalDataType where
    compare :: AnnotExternalDataType -> AnnotExternalDataType -> Ordering
compare AnnotExternalDataType
a AnnotExternalDataType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (AnnotExternalDataType -> Int
forall a. Enum a => a -> Int
P.fromEnum AnnotExternalDataType
a) (AnnotExternalDataType -> Int
forall a. Enum a => a -> Int
P.fromEnum AnnotExternalDataType
b)

type instance O.ParentTypes AnnotExternalDataType = '[]
instance O.HasParentTypes AnnotExternalDataType

foreign import ccall "poppler_annot_external_data_type_get_type" c_poppler_annot_external_data_type_get_type :: 
    IO GType

instance B.Types.TypedObject AnnotExternalDataType where
    glibType :: IO GType
glibType = IO GType
c_poppler_annot_external_data_type_get_type

instance B.Types.BoxedEnum AnnotExternalDataType

-- 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 (Int -> AdditionalActionType -> ShowS
[AdditionalActionType] -> ShowS
AdditionalActionType -> String
(Int -> AdditionalActionType -> ShowS)
-> (AdditionalActionType -> String)
-> ([AdditionalActionType] -> ShowS)
-> Show AdditionalActionType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AdditionalActionType] -> ShowS
$cshowList :: [AdditionalActionType] -> ShowS
show :: AdditionalActionType -> String
$cshow :: AdditionalActionType -> String
showsPrec :: Int -> AdditionalActionType -> ShowS
$cshowsPrec :: Int -> AdditionalActionType -> ShowS
Show, AdditionalActionType -> AdditionalActionType -> Bool
(AdditionalActionType -> AdditionalActionType -> Bool)
-> (AdditionalActionType -> AdditionalActionType -> Bool)
-> Eq AdditionalActionType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AdditionalActionType -> AdditionalActionType -> Bool
$c/= :: AdditionalActionType -> AdditionalActionType -> Bool
== :: AdditionalActionType -> AdditionalActionType -> Bool
$c== :: AdditionalActionType -> AdditionalActionType -> Bool
Eq)

instance P.Enum AdditionalActionType where
    fromEnum :: AdditionalActionType -> Int
fromEnum AdditionalActionType
AdditionalActionTypeFieldModified = Int
0
    fromEnum AdditionalActionType
AdditionalActionTypeFormatField = Int
1
    fromEnum AdditionalActionType
AdditionalActionTypeValidateField = Int
2
    fromEnum AdditionalActionType
AdditionalActionTypeCalculateField = Int
3
    fromEnum (AnotherAdditionalActionType Int
k) = Int
k

    toEnum :: Int -> AdditionalActionType
toEnum Int
0 = AdditionalActionType
AdditionalActionTypeFieldModified
    toEnum Int
1 = AdditionalActionType
AdditionalActionTypeFormatField
    toEnum Int
2 = AdditionalActionType
AdditionalActionTypeValidateField
    toEnum Int
3 = AdditionalActionType
AdditionalActionTypeCalculateField
    toEnum Int
k = Int -> AdditionalActionType
AnotherAdditionalActionType Int
k

instance P.Ord AdditionalActionType where
    compare :: AdditionalActionType -> AdditionalActionType -> Ordering
compare AdditionalActionType
a AdditionalActionType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (AdditionalActionType -> Int
forall a. Enum a => a -> Int
P.fromEnum AdditionalActionType
a) (AdditionalActionType -> Int
forall a. Enum a => a -> Int
P.fromEnum AdditionalActionType
b)

type instance O.ParentTypes AdditionalActionType = '[]
instance O.HasParentTypes AdditionalActionType

foreign import ccall "poppler_additional_action_type_get_type" c_poppler_additional_action_type_get_type :: 
    IO GType

instance B.Types.TypedObject AdditionalActionType where
    glibType :: IO GType
glibType = IO GType
c_poppler_additional_action_type_get_type

instance B.Types.BoxedEnum AdditionalActionType

-- 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
    | ActionTypeResetForm
    -- ^ resets form. Since 0.90
    | AnotherActionType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ActionType -> ShowS
[ActionType] -> ShowS
ActionType -> String
(Int -> ActionType -> ShowS)
-> (ActionType -> String)
-> ([ActionType] -> ShowS)
-> Show ActionType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ActionType] -> ShowS
$cshowList :: [ActionType] -> ShowS
show :: ActionType -> String
$cshow :: ActionType -> String
showsPrec :: Int -> ActionType -> ShowS
$cshowsPrec :: Int -> ActionType -> ShowS
Show, ActionType -> ActionType -> Bool
(ActionType -> ActionType -> Bool)
-> (ActionType -> ActionType -> Bool) -> Eq ActionType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ActionType -> ActionType -> Bool
$c/= :: ActionType -> ActionType -> Bool
== :: ActionType -> ActionType -> Bool
$c== :: ActionType -> ActionType -> Bool
Eq)

instance P.Enum ActionType where
    fromEnum :: ActionType -> Int
fromEnum ActionType
ActionTypeUnknown = Int
0
    fromEnum ActionType
ActionTypeNone = Int
1
    fromEnum ActionType
ActionTypeGotoDest = Int
2
    fromEnum ActionType
ActionTypeGotoRemote = Int
3
    fromEnum ActionType
ActionTypeLaunch = Int
4
    fromEnum ActionType
ActionTypeUri = Int
5
    fromEnum ActionType
ActionTypeNamed = Int
6
    fromEnum ActionType
ActionTypeMovie = Int
7
    fromEnum ActionType
ActionTypeRendition = Int
8
    fromEnum ActionType
ActionTypeOcgState = Int
9
    fromEnum ActionType
ActionTypeJavascript = Int
10
    fromEnum ActionType
ActionTypeResetForm = Int
11
    fromEnum (AnotherActionType Int
k) = Int
k

    toEnum :: Int -> ActionType
toEnum Int
0 = ActionType
ActionTypeUnknown
    toEnum Int
1 = ActionType
ActionTypeNone
    toEnum Int
2 = ActionType
ActionTypeGotoDest
    toEnum Int
3 = ActionType
ActionTypeGotoRemote
    toEnum Int
4 = ActionType
ActionTypeLaunch
    toEnum Int
5 = ActionType
ActionTypeUri
    toEnum Int
6 = ActionType
ActionTypeNamed
    toEnum Int
7 = ActionType
ActionTypeMovie
    toEnum Int
8 = ActionType
ActionTypeRendition
    toEnum Int
9 = ActionType
ActionTypeOcgState
    toEnum Int
10 = ActionType
ActionTypeJavascript
    toEnum Int
11 = ActionType
ActionTypeResetForm
    toEnum Int
k = Int -> ActionType
AnotherActionType Int
k

instance P.Ord ActionType where
    compare :: ActionType -> ActionType -> Ordering
compare ActionType
a ActionType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ActionType -> Int
forall a. Enum a => a -> Int
P.fromEnum ActionType
a) (ActionType -> Int
forall a. Enum a => a -> Int
P.fromEnum ActionType
b)

type instance O.ParentTypes ActionType = '[]
instance O.HasParentTypes ActionType

foreign import ccall "poppler_action_type_get_type" c_poppler_action_type_get_type :: 
    IO GType

instance B.Types.TypedObject ActionType where
    glibType :: IO GType
glibType = IO GType
c_poppler_action_type_get_type

instance B.Types.BoxedEnum ActionType

-- 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 (Int -> ActionMovieOperation -> ShowS
[ActionMovieOperation] -> ShowS
ActionMovieOperation -> String
(Int -> ActionMovieOperation -> ShowS)
-> (ActionMovieOperation -> String)
-> ([ActionMovieOperation] -> ShowS)
-> Show ActionMovieOperation
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ActionMovieOperation] -> ShowS
$cshowList :: [ActionMovieOperation] -> ShowS
show :: ActionMovieOperation -> String
$cshow :: ActionMovieOperation -> String
showsPrec :: Int -> ActionMovieOperation -> ShowS
$cshowsPrec :: Int -> ActionMovieOperation -> ShowS
Show, ActionMovieOperation -> ActionMovieOperation -> Bool
(ActionMovieOperation -> ActionMovieOperation -> Bool)
-> (ActionMovieOperation -> ActionMovieOperation -> Bool)
-> Eq ActionMovieOperation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ActionMovieOperation -> ActionMovieOperation -> Bool
$c/= :: ActionMovieOperation -> ActionMovieOperation -> Bool
== :: ActionMovieOperation -> ActionMovieOperation -> Bool
$c== :: ActionMovieOperation -> ActionMovieOperation -> Bool
Eq)

instance P.Enum ActionMovieOperation where
    fromEnum :: ActionMovieOperation -> Int
fromEnum ActionMovieOperation
ActionMovieOperationPlay = Int
0
    fromEnum ActionMovieOperation
ActionMovieOperationPause = Int
1
    fromEnum ActionMovieOperation
ActionMovieOperationResume = Int
2
    fromEnum ActionMovieOperation
ActionMovieOperationStop = Int
3
    fromEnum (AnotherActionMovieOperation Int
k) = Int
k

    toEnum :: Int -> ActionMovieOperation
toEnum Int
0 = ActionMovieOperation
ActionMovieOperationPlay
    toEnum Int
1 = ActionMovieOperation
ActionMovieOperationPause
    toEnum Int
2 = ActionMovieOperation
ActionMovieOperationResume
    toEnum Int
3 = ActionMovieOperation
ActionMovieOperationStop
    toEnum Int
k = Int -> ActionMovieOperation
AnotherActionMovieOperation Int
k

instance P.Ord ActionMovieOperation where
    compare :: ActionMovieOperation -> ActionMovieOperation -> Ordering
compare ActionMovieOperation
a ActionMovieOperation
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ActionMovieOperation -> Int
forall a. Enum a => a -> Int
P.fromEnum ActionMovieOperation
a) (ActionMovieOperation -> Int
forall a. Enum a => a -> Int
P.fromEnum ActionMovieOperation
b)

type instance O.ParentTypes ActionMovieOperation = '[]
instance O.HasParentTypes ActionMovieOperation

foreign import ccall "poppler_action_movie_operation_get_type" c_poppler_action_movie_operation_get_type :: 
    IO GType

instance B.Types.TypedObject ActionMovieOperation where
    glibType :: IO GType
glibType = IO GType
c_poppler_action_movie_operation_get_type

instance B.Types.BoxedEnum ActionMovieOperation

-- 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 (Int -> ActionLayerAction -> ShowS
[ActionLayerAction] -> ShowS
ActionLayerAction -> String
(Int -> ActionLayerAction -> ShowS)
-> (ActionLayerAction -> String)
-> ([ActionLayerAction] -> ShowS)
-> Show ActionLayerAction
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ActionLayerAction] -> ShowS
$cshowList :: [ActionLayerAction] -> ShowS
show :: ActionLayerAction -> String
$cshow :: ActionLayerAction -> String
showsPrec :: Int -> ActionLayerAction -> ShowS
$cshowsPrec :: Int -> ActionLayerAction -> ShowS
Show, ActionLayerAction -> ActionLayerAction -> Bool
(ActionLayerAction -> ActionLayerAction -> Bool)
-> (ActionLayerAction -> ActionLayerAction -> Bool)
-> Eq ActionLayerAction
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ActionLayerAction -> ActionLayerAction -> Bool
$c/= :: ActionLayerAction -> ActionLayerAction -> Bool
== :: ActionLayerAction -> ActionLayerAction -> Bool
$c== :: ActionLayerAction -> ActionLayerAction -> Bool
Eq)

instance P.Enum ActionLayerAction where
    fromEnum :: ActionLayerAction -> Int
fromEnum ActionLayerAction
ActionLayerActionOn = Int
0
    fromEnum ActionLayerAction
ActionLayerActionOff = Int
1
    fromEnum ActionLayerAction
ActionLayerActionToggle = Int
2
    fromEnum (AnotherActionLayerAction Int
k) = Int
k

    toEnum :: Int -> ActionLayerAction
toEnum Int
0 = ActionLayerAction
ActionLayerActionOn
    toEnum Int
1 = ActionLayerAction
ActionLayerActionOff
    toEnum Int
2 = ActionLayerAction
ActionLayerActionToggle
    toEnum Int
k = Int -> ActionLayerAction
AnotherActionLayerAction Int
k

instance P.Ord ActionLayerAction where
    compare :: ActionLayerAction -> ActionLayerAction -> Ordering
compare ActionLayerAction
a ActionLayerAction
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ActionLayerAction -> Int
forall a. Enum a => a -> Int
P.fromEnum ActionLayerAction
a) (ActionLayerAction -> Int
forall a. Enum a => a -> Int
P.fromEnum ActionLayerAction
b)

type instance O.ParentTypes ActionLayerAction = '[]
instance O.HasParentTypes ActionLayerAction

foreign import ccall "poppler_action_layer_action_get_type" c_poppler_action_layer_action_get_type :: 
    IO GType

instance B.Types.TypedObject ActionLayerAction where
    glibType :: IO GType
glibType = IO GType
c_poppler_action_layer_action_get_type

instance B.Types.BoxedEnum ActionLayerAction