#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Poppler.Enums
(
ActionLayerAction(..) ,
ActionMovieOperation(..) ,
ActionType(..) ,
AdditionalActionType(..) ,
AnnotExternalDataType(..) ,
AnnotFreeTextQuadding(..) ,
AnnotMarkupReplyType(..) ,
AnnotTextState(..) ,
AnnotType(..) ,
Backend(..) ,
DestType(..) ,
Error(..) ,
catchError ,
handleError ,
FontType(..) ,
FormButtonType(..) ,
FormChoiceType(..) ,
FormFieldType(..) ,
FormTextType(..) ,
MoviePlayMode(..) ,
PDFConformance(..) ,
PDFPart(..) ,
PDFSubtype(..) ,
PageLayout(..) ,
PageMode(..) ,
PageTransitionAlignment(..) ,
PageTransitionDirection(..) ,
PageTransitionType(..) ,
PrintDuplex(..) ,
PrintScaling(..) ,
SelectionStyle(..) ,
StructureBlockAlign(..) ,
StructureBorderStyle(..) ,
StructureElementKind(..) ,
StructureFormRole(..) ,
StructureFormState(..) ,
StructureGlyphOrientation(..) ,
StructureInlineAlign(..) ,
StructureListNumbering(..) ,
StructurePlacement(..) ,
StructureRubyAlign(..) ,
StructureRubyPosition(..) ,
StructureTableScope(..) ,
StructureTextAlign(..) ,
StructureTextDecoration(..) ,
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
data StructureWritingMode =
StructureWritingModeLrTb
| StructureWritingModeRlTb
| StructureWritingModeTbRl
| AnotherStructureWritingMode Int
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
data StructureTextDecoration =
StructureTextDecorationNone
| StructureTextDecorationUnderline
| StructureTextDecorationOverline
| StructureTextDecorationLinethrough
| AnotherStructureTextDecoration Int
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
data StructureTextAlign =
StructureTextAlignStart
| StructureTextAlignCenter
| StructureTextAlignEnd
| StructureTextAlignJustify
| AnotherStructureTextAlign Int
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
data StructureTableScope =
StructureTableScopeRow
| StructureTableScopeColumn
| StructureTableScopeBoth
| AnotherStructureTableScope Int
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
data StructureRubyPosition =
StructureRubyPositionBefore
| StructureRubyPositionAfter
| StructureRubyPositionWarichu
| StructureRubyPositionInline
| AnotherStructureRubyPosition Int
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
data StructureRubyAlign =
StructureRubyAlignStart
| StructureRubyAlignCenter
| StructureRubyAlignEnd
| StructureRubyAlignJustify
| StructureRubyAlignDistribute
| AnotherStructureRubyAlign Int
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
data StructurePlacement =
StructurePlacementBlock
| StructurePlacementInline
| StructurePlacementBefore
| StructurePlacementStart
| StructurePlacementEnd
| AnotherStructurePlacement Int
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
data StructureListNumbering =
StructureListNumberingNone
| StructureListNumberingDisc
| StructureListNumberingCircle
| StructureListNumberingSquare
| StructureListNumberingDecimal
| StructureListNumberingUpperRoman
| StructureListNumberingLowerRoman
| StructureListNumberingUpperAlpha
| StructureListNumberingLowerAlpha
| AnotherStructureListNumbering Int
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
data StructureInlineAlign =
StructureInlineAlignStart
| StructureInlineAlignCenter
| StructureInlineAlignEnd
| AnotherStructureInlineAlign Int
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
data StructureGlyphOrientation =
StructureGlyphOrientationAuto
| StructureGlyphOrientation0
| StructureGlyphOrientation90
| StructureGlyphOrientation180
| StructureGlyphOrientation270
| AnotherStructureGlyphOrientation Int
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
data StructureFormState =
StructureFormStateOn
| StructureFormStateOff
| StructureFormStateNeutral
| AnotherStructureFormState Int
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
data StructureFormRole =
StructureFormRoleUndefined
| StructureFormRoleRadioButton
| StructureFormRolePushButton
| StructureFormRoleTextValue
| StructureFormRoleCheckbox
| AnotherStructureFormRole Int
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
data StructureElementKind =
StructureElementKindContent
| StructureElementKindObjectReference
| StructureElementKindDocument
| StructureElementKindPart
| StructureElementKindArticle
| StructureElementKindSection
| StructureElementKindDiv
| StructureElementKindSpan
| StructureElementKindQuote
| StructureElementKindNote
| StructureElementKindReference
| StructureElementKindBibentry
| StructureElementKindCode
| StructureElementKindLink
| StructureElementKindAnnot
| StructureElementKindBlockquote
| StructureElementKindCaption
| StructureElementKindNonstruct
| StructureElementKindToc
| StructureElementKindTocItem
| StructureElementKindIndex
| StructureElementKindPrivate
| StructureElementKindParagraph
| StructureElementKindHeading
| StructureElementKindHeading1
| StructureElementKindHeading2
| StructureElementKindHeading3
| StructureElementKindHeading4
| StructureElementKindHeading5
| StructureElementKindHeading6
| StructureElementKindList
| StructureElementKindListItem
| StructureElementKindListLabel
| StructureElementKindListBody
| StructureElementKindTable
| StructureElementKindTableRow
| StructureElementKindTableHeading
| StructureElementKindTableData
|
|
| StructureElementKindTableBody
| StructureElementKindRuby
| StructureElementKindRubyBaseText
| StructureElementKindRubyAnnotText
| StructureElementKindRubyPunctuation
| StructureElementKindWarichu
| StructureElementKindWarichuText
| StructureElementKindWarichuPunctuation
| StructureElementKindFigure
| StructureElementKindFormula
| StructureElementKindForm
| AnotherStructureElementKind Int
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
data StructureBorderStyle =
StructureBorderStyleNone
| StructureBorderStyleHidden
| StructureBorderStyleDotted
| StructureBorderStyleDashed
| StructureBorderStyleSolid
| StructureBorderStyleDouble
| StructureBorderStyleGroove
| StructureBorderStyleInset
| StructureBorderStyleOutset
| AnotherStructureBorderStyle Int
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
data StructureBlockAlign =
StructureBlockAlignBefore
| StructureBlockAlignMiddle
| StructureBlockAlignAfter
| StructureBlockAlignJustify
| AnotherStructureBlockAlign Int
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
data SelectionStyle =
SelectionStyleGlyph
| SelectionStyleWord
| SelectionStyleLine
| AnotherSelectionStyle Int
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
data PrintScaling =
PrintScalingAppDefault
| PrintScalingNone
| AnotherPrintScaling Int
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
data PrintDuplex =
PrintDuplexNone
| PrintDuplexSimplex
| PrintDuplexDuplexFlipShortEdge
| PrintDuplexDuplexFlipLongEdge
| AnotherPrintDuplex Int
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
data PageTransitionType =
PageTransitionTypeReplace
| PageTransitionTypeSplit
| PageTransitionTypeBlinds
| PageTransitionTypeBox
| PageTransitionTypeWipe
| PageTransitionTypeDissolve
| PageTransitionTypeGlitter
| PageTransitionTypeFly
| PageTransitionTypePush
| PageTransitionTypeCover
| PageTransitionTypeUncover
| PageTransitionTypeFade
| AnotherPageTransitionType Int
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
data PageTransitionDirection =
PageTransitionDirectionInward
| PageTransitionDirectionOutward
| AnotherPageTransitionDirection Int
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
data PageTransitionAlignment =
PageTransitionAlignmentHorizontal
| PageTransitionAlignmentVertical
| AnotherPageTransitionAlignment Int
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
data PageMode =
PageModeUnset
| PageModeNone
| PageModeUseOutlines
| PageModeUseThumbs
| PageModeFullScreen
| PageModeUseOc
| PageModeUseAttachments
| AnotherPageMode Int
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
data PageLayout =
PageLayoutUnset
| PageLayoutSinglePage
| PageLayoutOneColumn
| PageLayoutTwoColumnLeft
| PageLayoutTwoColumnRight
| PageLayoutTwoPageLeft
|
| AnotherPageLayout Int
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
data PDFSubtype =
PDFSubtypeUnset
| PDFSubtypePdfA
| PDFSubtypePdfE
| PDFSubtypePdfUa
| PDFSubtypePdfVt
| PDFSubtypePdfX
| PDFSubtypeNone
| AnotherPDFSubtype Int
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
data PDFPart =
PDFPartUnset
| PDFPart1
| PDFPart2
| PDFPart3
| PDFPart4
| PDFPart5
| PDFPart6
| PDFPart7
| PDFPart8
| PDFPartNone
| AnotherPDFPart Int
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
data PDFConformance =
PDFConformanceUnset
| PDFConformanceA
| PDFConformanceB
| PDFConformanceG
| PDFConformanceN
| PDFConformanceP
| PDFConformancePg
| PDFConformanceU
| PDFConformanceNone
| AnotherPDFConformance Int
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
data MoviePlayMode =
MoviePlayModeOnce
| MoviePlayModeOpen
| MoviePlayModeRepeat
| MoviePlayModePalindrome
| AnotherMoviePlayMode Int
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
data FormTextType =
FormTextTypeNormal
| FormTextTypeMultiline
| FormTextTypeFileSelect
| AnotherFormTextType Int
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
data FormFieldType =
FormFieldTypeUnknown
| FormFieldTypeButton
| FormFieldTypeText
| FormFieldTypeChoice
| FormFieldTypeSignature
| AnotherFormFieldType Int
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
data FormChoiceType =
FormChoiceTypeCombo
| FormChoiceTypeList
| AnotherFormChoiceType Int
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
data FormButtonType =
FormButtonTypePush
| FormButtonTypeCheck
| FormButtonTypeRadio
| AnotherFormButtonType Int
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
data FontType =
FontTypeUnknown
| FontTypeType1
| FontTypeType1c
| FontTypeType1cot
| FontTypeType3
| FontTypeTruetype
| FontTypeTruetypeot
| FontTypeCidType0
| FontTypeCidType0c
| FontTypeCidType0cot
| FontTypeCidType2
| FontTypeCidType2ot
| AnotherFontType Int
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
data Error =
ErrorInvalid
| ErrorEncrypted
| ErrorOpenFile
| ErrorBadCatalog
| ErrorDamaged
| AnotherError Int
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"
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
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
data DestType =
DestTypeUnknown
| DestTypeXyz
| DestTypeFit
| DestTypeFith
| DestTypeFitv
| DestTypeFitr
| DestTypeFitb
| DestTypeFitbh
| DestTypeFitbv
| DestTypeNamed
| AnotherDestType Int
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
data Backend =
BackendUnknown
| BackendSplash
| BackendCairo
| AnotherBackend Int
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
data AnnotType =
AnnotTypeUnknown
| AnnotTypeText
| AnnotTypeLink
| AnnotTypeFreeText
| AnnotTypeLine
| AnnotTypeSquare
| AnnotTypeCircle
| AnnotTypePolygon
| AnnotTypePolyLine
| AnnotTypeHighlight
| AnnotTypeUnderline
| AnnotTypeSquiggly
| AnnotTypeStrikeOut
| AnnotTypeStamp
| AnnotTypeCaret
| AnnotTypeInk
|
| AnnotTypeFileAttachment
| AnnotTypeSound
| AnnotTypeMovie
| AnnotTypeWidget
| AnnotTypeScreen
| AnnotTypePrinterMark
| AnnotTypeTrapNet
| AnnotTypeWatermark
| AnnotType3d
| AnotherAnnotType Int
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
data AnnotTextState =
AnnotTextStateMarked
| AnnotTextStateUnmarked
| AnnotTextStateAccepted
| AnnotTextStateRejected
| AnnotTextStateCancelled
| AnnotTextStateCompleted
| AnnotTextStateNone
| AnnotTextStateUnknown
| AnotherAnnotTextState Int
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
data AnnotMarkupReplyType =
AnnotMarkupReplyTypeR
| AnnotMarkupReplyTypeGroup
| AnotherAnnotMarkupReplyType Int
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
data AnnotFreeTextQuadding =
AnnotFreeTextQuaddingLeftJustified
| AnnotFreeTextQuaddingCentered
| AnnotFreeTextQuaddingRightJustified
| AnotherAnnotFreeTextQuadding Int
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
data AnnotExternalDataType =
AnnotExternalDataType3d
| AnnotExternalDataTypeUnknown
| AnotherAnnotExternalDataType Int
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
data AdditionalActionType =
AdditionalActionTypeFieldModified
| AdditionalActionTypeFormatField
| AdditionalActionTypeValidateField
| AdditionalActionTypeCalculateField
| AnotherAdditionalActionType Int
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
data ActionType =
ActionTypeUnknown
| ActionTypeNone
| ActionTypeGotoDest
| ActionTypeGotoRemote
| ActionTypeLaunch
| ActionTypeUri
| ActionTypeNamed
| ActionTypeMovie
| ActionTypeRendition
| ActionTypeOcgState
| ActionTypeJavascript
| ActionTypeResetForm
| AnotherActionType Int
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
data ActionMovieOperation =
ActionMovieOperationPlay
| ActionMovieOperationPause
| ActionMovieOperationResume
| ActionMovieOperationStop
| AnotherActionMovieOperation Int
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
data ActionLayerAction =
ActionLayerActionOn
| ActionLayerActionOff
| ActionLayerActionToggle
| AnotherActionLayerAction Int
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