#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(..) ,
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.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.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
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)
foreign import ccall "poppler_structure_writing_mode_get_type" c_poppler_structure_writing_mode_get_type ::
IO GType
instance BoxedEnum StructureWritingMode where
boxedEnumType :: StructureWritingMode -> IO GType
boxedEnumType StructureWritingMode
_ = IO GType
c_poppler_structure_writing_mode_get_type
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)
foreign import ccall "poppler_structure_text_decoration_get_type" c_poppler_structure_text_decoration_get_type ::
IO GType
instance BoxedEnum StructureTextDecoration where
boxedEnumType :: StructureTextDecoration -> IO GType
boxedEnumType StructureTextDecoration
_ = IO GType
c_poppler_structure_text_decoration_get_type
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)
foreign import ccall "poppler_structure_text_align_get_type" c_poppler_structure_text_align_get_type ::
IO GType
instance BoxedEnum StructureTextAlign where
boxedEnumType :: StructureTextAlign -> IO GType
boxedEnumType StructureTextAlign
_ = IO GType
c_poppler_structure_text_align_get_type
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)
foreign import ccall "poppler_structure_table_scope_get_type" c_poppler_structure_table_scope_get_type ::
IO GType
instance BoxedEnum StructureTableScope where
boxedEnumType :: StructureTableScope -> IO GType
boxedEnumType StructureTableScope
_ = IO GType
c_poppler_structure_table_scope_get_type
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)
foreign import ccall "poppler_structure_ruby_position_get_type" c_poppler_structure_ruby_position_get_type ::
IO GType
instance BoxedEnum StructureRubyPosition where
boxedEnumType :: StructureRubyPosition -> IO GType
boxedEnumType StructureRubyPosition
_ = IO GType
c_poppler_structure_ruby_position_get_type
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)
foreign import ccall "poppler_structure_ruby_align_get_type" c_poppler_structure_ruby_align_get_type ::
IO GType
instance BoxedEnum StructureRubyAlign where
boxedEnumType :: StructureRubyAlign -> IO GType
boxedEnumType StructureRubyAlign
_ = IO GType
c_poppler_structure_ruby_align_get_type
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)
foreign import ccall "poppler_structure_placement_get_type" c_poppler_structure_placement_get_type ::
IO GType
instance BoxedEnum StructurePlacement where
boxedEnumType :: StructurePlacement -> IO GType
boxedEnumType StructurePlacement
_ = IO GType
c_poppler_structure_placement_get_type
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)
foreign import ccall "poppler_structure_list_numbering_get_type" c_poppler_structure_list_numbering_get_type ::
IO GType
instance BoxedEnum StructureListNumbering where
boxedEnumType :: StructureListNumbering -> IO GType
boxedEnumType StructureListNumbering
_ = IO GType
c_poppler_structure_list_numbering_get_type
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)
foreign import ccall "poppler_structure_inline_align_get_type" c_poppler_structure_inline_align_get_type ::
IO GType
instance BoxedEnum StructureInlineAlign where
boxedEnumType :: StructureInlineAlign -> IO GType
boxedEnumType StructureInlineAlign
_ = IO GType
c_poppler_structure_inline_align_get_type
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)
foreign import ccall "poppler_structure_glyph_orientation_get_type" c_poppler_structure_glyph_orientation_get_type ::
IO GType
instance BoxedEnum StructureGlyphOrientation where
boxedEnumType :: StructureGlyphOrientation -> IO GType
boxedEnumType StructureGlyphOrientation
_ = IO GType
c_poppler_structure_glyph_orientation_get_type
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)
foreign import ccall "poppler_structure_form_state_get_type" c_poppler_structure_form_state_get_type ::
IO GType
instance BoxedEnum StructureFormState where
boxedEnumType :: StructureFormState -> IO GType
boxedEnumType StructureFormState
_ = IO GType
c_poppler_structure_form_state_get_type
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)
foreign import ccall "poppler_structure_form_role_get_type" c_poppler_structure_form_role_get_type ::
IO GType
instance BoxedEnum StructureFormRole where
boxedEnumType :: StructureFormRole -> IO GType
boxedEnumType StructureFormRole
_ = IO GType
c_poppler_structure_form_role_get_type
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)
foreign import ccall "poppler_structure_element_kind_get_type" c_poppler_structure_element_kind_get_type ::
IO GType
instance BoxedEnum StructureElementKind where
boxedEnumType :: StructureElementKind -> IO GType
boxedEnumType StructureElementKind
_ = IO GType
c_poppler_structure_element_kind_get_type
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)
foreign import ccall "poppler_structure_border_style_get_type" c_poppler_structure_border_style_get_type ::
IO GType
instance BoxedEnum StructureBorderStyle where
boxedEnumType :: StructureBorderStyle -> IO GType
boxedEnumType StructureBorderStyle
_ = IO GType
c_poppler_structure_border_style_get_type
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)
foreign import ccall "poppler_structure_block_align_get_type" c_poppler_structure_block_align_get_type ::
IO GType
instance BoxedEnum StructureBlockAlign where
boxedEnumType :: StructureBlockAlign -> IO GType
boxedEnumType StructureBlockAlign
_ = IO GType
c_poppler_structure_block_align_get_type
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)
foreign import ccall "poppler_selection_style_get_type" c_poppler_selection_style_get_type ::
IO GType
instance BoxedEnum SelectionStyle where
boxedEnumType :: SelectionStyle -> IO GType
boxedEnumType SelectionStyle
_ = IO GType
c_poppler_selection_style_get_type
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)
foreign import ccall "poppler_print_scaling_get_type" c_poppler_print_scaling_get_type ::
IO GType
instance BoxedEnum PrintScaling where
boxedEnumType :: PrintScaling -> IO GType
boxedEnumType PrintScaling
_ = IO GType
c_poppler_print_scaling_get_type
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)
foreign import ccall "poppler_page_transition_type_get_type" c_poppler_page_transition_type_get_type ::
IO GType
instance BoxedEnum PageTransitionType where
boxedEnumType :: PageTransitionType -> IO GType
boxedEnumType PageTransitionType
_ = IO GType
c_poppler_page_transition_type_get_type
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)
foreign import ccall "poppler_page_transition_direction_get_type" c_poppler_page_transition_direction_get_type ::
IO GType
instance BoxedEnum PageTransitionDirection where
boxedEnumType :: PageTransitionDirection -> IO GType
boxedEnumType PageTransitionDirection
_ = IO GType
c_poppler_page_transition_direction_get_type
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)
foreign import ccall "poppler_page_transition_alignment_get_type" c_poppler_page_transition_alignment_get_type ::
IO GType
instance BoxedEnum PageTransitionAlignment where
boxedEnumType :: PageTransitionAlignment -> IO GType
boxedEnumType PageTransitionAlignment
_ = IO GType
c_poppler_page_transition_alignment_get_type
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)
foreign import ccall "poppler_page_mode_get_type" c_poppler_page_mode_get_type ::
IO GType
instance BoxedEnum PageMode where
boxedEnumType :: PageMode -> IO GType
boxedEnumType PageMode
_ = IO GType
c_poppler_page_mode_get_type
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)
foreign import ccall "poppler_page_layout_get_type" c_poppler_page_layout_get_type ::
IO GType
instance BoxedEnum PageLayout where
boxedEnumType :: PageLayout -> IO GType
boxedEnumType PageLayout
_ = IO GType
c_poppler_page_layout_get_type
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)
foreign import ccall "poppler_pdf_subtype_get_type" c_poppler_pdf_subtype_get_type ::
IO GType
instance BoxedEnum PDFSubtype where
boxedEnumType :: PDFSubtype -> IO GType
boxedEnumType PDFSubtype
_ = IO GType
c_poppler_pdf_subtype_get_type
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)
foreign import ccall "poppler_pdf_part_get_type" c_poppler_pdf_part_get_type ::
IO GType
instance BoxedEnum PDFPart where
boxedEnumType :: PDFPart -> IO GType
boxedEnumType PDFPart
_ = IO GType
c_poppler_pdf_part_get_type
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)
foreign import ccall "poppler_pdf_conformance_get_type" c_poppler_pdf_conformance_get_type ::
IO GType
instance BoxedEnum PDFConformance where
boxedEnumType :: PDFConformance -> IO GType
boxedEnumType PDFConformance
_ = IO GType
c_poppler_pdf_conformance_get_type
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)
foreign import ccall "poppler_movie_play_mode_get_type" c_poppler_movie_play_mode_get_type ::
IO GType
instance BoxedEnum MoviePlayMode where
boxedEnumType :: MoviePlayMode -> IO GType
boxedEnumType MoviePlayMode
_ = IO GType
c_poppler_movie_play_mode_get_type
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)
foreign import ccall "poppler_form_text_type_get_type" c_poppler_form_text_type_get_type ::
IO GType
instance BoxedEnum FormTextType where
boxedEnumType :: FormTextType -> IO GType
boxedEnumType FormTextType
_ = IO GType
c_poppler_form_text_type_get_type
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)
foreign import ccall "poppler_form_field_type_get_type" c_poppler_form_field_type_get_type ::
IO GType
instance BoxedEnum FormFieldType where
boxedEnumType :: FormFieldType -> IO GType
boxedEnumType FormFieldType
_ = IO GType
c_poppler_form_field_type_get_type
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)
foreign import ccall "poppler_form_choice_type_get_type" c_poppler_form_choice_type_get_type ::
IO GType
instance BoxedEnum FormChoiceType where
boxedEnumType :: FormChoiceType -> IO GType
boxedEnumType FormChoiceType
_ = IO GType
c_poppler_form_choice_type_get_type
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)
foreign import ccall "poppler_form_button_type_get_type" c_poppler_form_button_type_get_type ::
IO GType
instance BoxedEnum FormButtonType where
boxedEnumType :: FormButtonType -> IO GType
boxedEnumType FormButtonType
_ = IO GType
c_poppler_form_button_type_get_type
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)
foreign import ccall "poppler_font_type_get_type" c_poppler_font_type_get_type ::
IO GType
instance BoxedEnum FontType where
boxedEnumType :: FontType -> IO GType
boxedEnumType FontType
_ = IO GType
c_poppler_font_type_get_type
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 :: 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 :: (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
foreign import ccall "poppler_error_get_type" c_poppler_error_get_type ::
IO GType
instance BoxedEnum Error where
boxedEnumType :: Error -> IO GType
boxedEnumType Error
_ = IO GType
c_poppler_error_get_type
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)
foreign import ccall "poppler_dest_type_get_type" c_poppler_dest_type_get_type ::
IO GType
instance BoxedEnum DestType where
boxedEnumType :: DestType -> IO GType
boxedEnumType DestType
_ = IO GType
c_poppler_dest_type_get_type
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)
foreign import ccall "poppler_backend_get_type" c_poppler_backend_get_type ::
IO GType
instance BoxedEnum Backend where
boxedEnumType :: Backend -> IO GType
boxedEnumType Backend
_ = IO GType
c_poppler_backend_get_type
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)
foreign import ccall "poppler_annot_type_get_type" c_poppler_annot_type_get_type ::
IO GType
instance BoxedEnum AnnotType where
boxedEnumType :: AnnotType -> IO GType
boxedEnumType AnnotType
_ = IO GType
c_poppler_annot_type_get_type
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)
foreign import ccall "poppler_annot_text_state_get_type" c_poppler_annot_text_state_get_type ::
IO GType
instance BoxedEnum AnnotTextState where
boxedEnumType :: AnnotTextState -> IO GType
boxedEnumType AnnotTextState
_ = IO GType
c_poppler_annot_text_state_get_type
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)
foreign import ccall "poppler_annot_markup_reply_type_get_type" c_poppler_annot_markup_reply_type_get_type ::
IO GType
instance BoxedEnum AnnotMarkupReplyType where
boxedEnumType :: AnnotMarkupReplyType -> IO GType
boxedEnumType AnnotMarkupReplyType
_ = IO GType
c_poppler_annot_markup_reply_type_get_type
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)
foreign import ccall "poppler_annot_free_text_quadding_get_type" c_poppler_annot_free_text_quadding_get_type ::
IO GType
instance BoxedEnum AnnotFreeTextQuadding where
boxedEnumType :: AnnotFreeTextQuadding -> IO GType
boxedEnumType AnnotFreeTextQuadding
_ = IO GType
c_poppler_annot_free_text_quadding_get_type
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)
foreign import ccall "poppler_annot_external_data_type_get_type" c_poppler_annot_external_data_type_get_type ::
IO GType
instance BoxedEnum AnnotExternalDataType where
boxedEnumType :: AnnotExternalDataType -> IO GType
boxedEnumType AnnotExternalDataType
_ = IO GType
c_poppler_annot_external_data_type_get_type
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)
foreign import ccall "poppler_additional_action_type_get_type" c_poppler_additional_action_type_get_type ::
IO GType
instance BoxedEnum AdditionalActionType where
boxedEnumType :: AdditionalActionType -> IO GType
boxedEnumType AdditionalActionType
_ = IO GType
c_poppler_additional_action_type_get_type
data ActionType =
ActionTypeUnknown
| ActionTypeNone
| ActionTypeGotoDest
| ActionTypeGotoRemote
| ActionTypeLaunch
| ActionTypeUri
| ActionTypeNamed
| ActionTypeMovie
| ActionTypeRendition
| ActionTypeOcgState
| ActionTypeJavascript
| 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 (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
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)
foreign import ccall "poppler_action_type_get_type" c_poppler_action_type_get_type ::
IO GType
instance BoxedEnum ActionType where
boxedEnumType :: ActionType -> IO GType
boxedEnumType ActionType
_ = IO GType
c_poppler_action_type_get_type
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)
foreign import ccall "poppler_action_movie_operation_get_type" c_poppler_action_movie_operation_get_type ::
IO GType
instance BoxedEnum ActionMovieOperation where
boxedEnumType :: ActionMovieOperation -> IO GType
boxedEnumType ActionMovieOperation
_ = IO GType
c_poppler_action_movie_operation_get_type
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)
foreign import ccall "poppler_action_layer_action_get_type" c_poppler_action_layer_action_get_type ::
IO GType
instance BoxedEnum ActionLayerAction where
boxedEnumType :: ActionLayerAction -> IO GType
boxedEnumType ActionLayerAction
_ = IO GType
c_poppler_action_layer_action_get_type