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