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

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

module GI.Poppler.Flags
    ( 

 -- * Flags
-- ** AnnotFlag #flag:AnnotFlag#

    AnnotFlag(..)                           ,


-- ** FindFlags #flag:FindFlags#

    FindFlags(..)                           ,


-- ** Permissions #flag:Permissions#

    Permissions(..)                         ,


-- ** PrintFlags #flag:PrintFlags#

    PrintFlags(..)                          ,


-- ** StructureGetTextFlags #flag:StructureGetTextFlags#

    StructureGetTextFlags(..)               ,


-- ** ViewerPreferences #flag:ViewerPreferences#

    ViewerPreferences(..)                   ,




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.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


-- Flags ViewerPreferences
-- | Viewer preferences
data ViewerPreferences = 
      ViewerPreferencesUnset
    -- ^ no preferences set
    | ViewerPreferencesHideToolbar
    -- ^ hider toolbars when document is active
    | ViewerPreferencesHideMenubar
    -- ^ hide menu bar when document is active
    | ViewerPreferencesHideWindowui
    -- ^ hide UI elements in document\'s window
    | ViewerPreferencesFitWindow
    -- ^ resize document\'s window to fit the size of the first displayed page
    | ViewerPreferencesCenterWindow
    -- ^ position the document\'s window in the center of the screen
    | ViewerPreferencesDisplayDocTitle
    -- ^ display document title in window\'s title bar
    | ViewerPreferencesDirectionRtl
    -- ^ the predominant reading order for text is right to left
    | AnotherViewerPreferences Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ViewerPreferences -> ShowS
[ViewerPreferences] -> ShowS
ViewerPreferences -> String
(Int -> ViewerPreferences -> ShowS)
-> (ViewerPreferences -> String)
-> ([ViewerPreferences] -> ShowS)
-> Show ViewerPreferences
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ViewerPreferences] -> ShowS
$cshowList :: [ViewerPreferences] -> ShowS
show :: ViewerPreferences -> String
$cshow :: ViewerPreferences -> String
showsPrec :: Int -> ViewerPreferences -> ShowS
$cshowsPrec :: Int -> ViewerPreferences -> ShowS
Show, ViewerPreferences -> ViewerPreferences -> Bool
(ViewerPreferences -> ViewerPreferences -> Bool)
-> (ViewerPreferences -> ViewerPreferences -> Bool)
-> Eq ViewerPreferences
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ViewerPreferences -> ViewerPreferences -> Bool
$c/= :: ViewerPreferences -> ViewerPreferences -> Bool
== :: ViewerPreferences -> ViewerPreferences -> Bool
$c== :: ViewerPreferences -> ViewerPreferences -> Bool
Eq)

instance P.Enum ViewerPreferences where
    fromEnum :: ViewerPreferences -> Int
fromEnum ViewerPreferencesUnset = 0
    fromEnum ViewerPreferencesHideToolbar = 1
    fromEnum ViewerPreferencesHideMenubar = 2
    fromEnum ViewerPreferencesHideWindowui = 4
    fromEnum ViewerPreferencesFitWindow = 8
    fromEnum ViewerPreferencesCenterWindow = 16
    fromEnum ViewerPreferencesDisplayDocTitle = 32
    fromEnum ViewerPreferencesDirectionRtl = 64
    fromEnum (AnotherViewerPreferences k :: Int
k) = Int
k

    toEnum :: Int -> ViewerPreferences
toEnum 0 = ViewerPreferences
ViewerPreferencesUnset
    toEnum 1 = ViewerPreferences
ViewerPreferencesHideToolbar
    toEnum 2 = ViewerPreferences
ViewerPreferencesHideMenubar
    toEnum 4 = ViewerPreferences
ViewerPreferencesHideWindowui
    toEnum 8 = ViewerPreferences
ViewerPreferencesFitWindow
    toEnum 16 = ViewerPreferences
ViewerPreferencesCenterWindow
    toEnum 32 = ViewerPreferences
ViewerPreferencesDisplayDocTitle
    toEnum 64 = ViewerPreferences
ViewerPreferencesDirectionRtl
    toEnum k :: Int
k = Int -> ViewerPreferences
AnotherViewerPreferences Int
k

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

foreign import ccall "poppler_viewer_preferences_get_type" c_poppler_viewer_preferences_get_type :: 
    IO GType

instance BoxedFlags ViewerPreferences where
    boxedFlagsType :: Proxy ViewerPreferences -> IO GType
boxedFlagsType _ = IO GType
c_poppler_viewer_preferences_get_type

instance IsGFlag ViewerPreferences

-- Flags StructureGetTextFlags
-- | /No description available in the introspection data./
data StructureGetTextFlags = 
      StructureGetTextFlagsNone
    -- ^ No flags.
    | StructureGetTextFlagsRecursive
    -- ^ For non-leaf, non-content
    --    elements, recursively obtain the text from all the elements
    --    enclosed in the subtree.
    | AnotherStructureGetTextFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> StructureGetTextFlags -> ShowS
[StructureGetTextFlags] -> ShowS
StructureGetTextFlags -> String
(Int -> StructureGetTextFlags -> ShowS)
-> (StructureGetTextFlags -> String)
-> ([StructureGetTextFlags] -> ShowS)
-> Show StructureGetTextFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StructureGetTextFlags] -> ShowS
$cshowList :: [StructureGetTextFlags] -> ShowS
show :: StructureGetTextFlags -> String
$cshow :: StructureGetTextFlags -> String
showsPrec :: Int -> StructureGetTextFlags -> ShowS
$cshowsPrec :: Int -> StructureGetTextFlags -> ShowS
Show, StructureGetTextFlags -> StructureGetTextFlags -> Bool
(StructureGetTextFlags -> StructureGetTextFlags -> Bool)
-> (StructureGetTextFlags -> StructureGetTextFlags -> Bool)
-> Eq StructureGetTextFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StructureGetTextFlags -> StructureGetTextFlags -> Bool
$c/= :: StructureGetTextFlags -> StructureGetTextFlags -> Bool
== :: StructureGetTextFlags -> StructureGetTextFlags -> Bool
$c== :: StructureGetTextFlags -> StructureGetTextFlags -> Bool
Eq)

instance P.Enum StructureGetTextFlags where
    fromEnum :: StructureGetTextFlags -> Int
fromEnum StructureGetTextFlagsNone = 0
    fromEnum StructureGetTextFlagsRecursive = 1
    fromEnum (AnotherStructureGetTextFlags k :: Int
k) = Int
k

    toEnum :: Int -> StructureGetTextFlags
toEnum 0 = StructureGetTextFlags
StructureGetTextFlagsNone
    toEnum 1 = StructureGetTextFlags
StructureGetTextFlagsRecursive
    toEnum k :: Int
k = Int -> StructureGetTextFlags
AnotherStructureGetTextFlags Int
k

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

foreign import ccall "poppler_structure_get_text_flags_get_type" c_poppler_structure_get_text_flags_get_type :: 
    IO GType

instance BoxedFlags StructureGetTextFlags where
    boxedFlagsType :: Proxy StructureGetTextFlags -> IO GType
boxedFlagsType _ = IO GType
c_poppler_structure_get_text_flags_get_type

instance IsGFlag StructureGetTextFlags

-- Flags PrintFlags
-- | Printing flags
-- 
-- /Since: 0.16/
data PrintFlags = 
      PrintFlagsDocument
    -- ^ print main document contents
    | PrintFlagsMarkupAnnots
    -- ^ print document and markup annotations
    | PrintFlagsStampAnnotsOnly
    -- ^ print document and only stamp annotations
    | PrintFlagsAll
    -- ^ print main document contents and all markup annotations
    | AnotherPrintFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PrintFlags -> ShowS
[PrintFlags] -> ShowS
PrintFlags -> String
(Int -> PrintFlags -> ShowS)
-> (PrintFlags -> String)
-> ([PrintFlags] -> ShowS)
-> Show PrintFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PrintFlags] -> ShowS
$cshowList :: [PrintFlags] -> ShowS
show :: PrintFlags -> String
$cshow :: PrintFlags -> String
showsPrec :: Int -> PrintFlags -> ShowS
$cshowsPrec :: Int -> PrintFlags -> ShowS
Show, PrintFlags -> PrintFlags -> Bool
(PrintFlags -> PrintFlags -> Bool)
-> (PrintFlags -> PrintFlags -> Bool) -> Eq PrintFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PrintFlags -> PrintFlags -> Bool
$c/= :: PrintFlags -> PrintFlags -> Bool
== :: PrintFlags -> PrintFlags -> Bool
$c== :: PrintFlags -> PrintFlags -> Bool
Eq)

instance P.Enum PrintFlags where
    fromEnum :: PrintFlags -> Int
fromEnum PrintFlagsDocument = 0
    fromEnum PrintFlagsMarkupAnnots = 1
    fromEnum PrintFlagsStampAnnotsOnly = 2
    fromEnum PrintFlagsAll = 1
    fromEnum (AnotherPrintFlags k :: Int
k) = Int
k

    toEnum :: Int -> PrintFlags
toEnum 0 = PrintFlags
PrintFlagsDocument
    toEnum 1 = PrintFlags
PrintFlagsMarkupAnnots
    toEnum 2 = PrintFlags
PrintFlagsStampAnnotsOnly
    toEnum k :: Int
k = Int -> PrintFlags
AnotherPrintFlags Int
k

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

foreign import ccall "poppler_print_flags_get_type" c_poppler_print_flags_get_type :: 
    IO GType

instance BoxedFlags PrintFlags where
    boxedFlagsType :: Proxy PrintFlags -> IO GType
boxedFlagsType _ = IO GType
c_poppler_print_flags_get_type

instance IsGFlag PrintFlags

-- Flags Permissions
-- | Permissions
data Permissions = 
      PermissionsOkToPrint
    -- ^ document can be printer
    | PermissionsOkToModify
    -- ^ document contents can be modified
    | PermissionsOkToCopy
    -- ^ document can be copied
    | PermissionsOkToAddNotes
    -- ^ annotations can added to the document
    | PermissionsOkToFillForm
    -- ^ interactive form fields can be filled in
    | PermissionsOkToExtractContents
    -- ^ extract text and graphics
    -- (in support of accessibility to users with disabilities or for other purposes). Since 0.18
    | PermissionsOkToAssemble
    -- ^ assemble the document (insert, rotate, or delete pages and create
    -- bookmarks or thumbnail images). Since 0.18
    | PermissionsOkToPrintHighResolution
    -- ^ document can be printer at high resolution. Since 0.18
    | PermissionsFull
    -- ^ document permits all operations
    | AnotherPermissions Int
    -- ^ Catch-all for unknown values
    deriving (Int -> Permissions -> ShowS
[Permissions] -> ShowS
Permissions -> String
(Int -> Permissions -> ShowS)
-> (Permissions -> String)
-> ([Permissions] -> ShowS)
-> Show Permissions
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Permissions] -> ShowS
$cshowList :: [Permissions] -> ShowS
show :: Permissions -> String
$cshow :: Permissions -> String
showsPrec :: Int -> Permissions -> ShowS
$cshowsPrec :: Int -> Permissions -> ShowS
Show, Permissions -> Permissions -> Bool
(Permissions -> Permissions -> Bool)
-> (Permissions -> Permissions -> Bool) -> Eq Permissions
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Permissions -> Permissions -> Bool
$c/= :: Permissions -> Permissions -> Bool
== :: Permissions -> Permissions -> Bool
$c== :: Permissions -> Permissions -> Bool
Eq)

instance P.Enum Permissions where
    fromEnum :: Permissions -> Int
fromEnum PermissionsOkToPrint = 1
    fromEnum PermissionsOkToModify = 2
    fromEnum PermissionsOkToCopy = 4
    fromEnum PermissionsOkToAddNotes = 8
    fromEnum PermissionsOkToFillForm = 16
    fromEnum PermissionsOkToExtractContents = 32
    fromEnum PermissionsOkToAssemble = 64
    fromEnum PermissionsOkToPrintHighResolution = 128
    fromEnum PermissionsFull = 255
    fromEnum (AnotherPermissions k :: Int
k) = Int
k

    toEnum :: Int -> Permissions
toEnum 1 = Permissions
PermissionsOkToPrint
    toEnum 2 = Permissions
PermissionsOkToModify
    toEnum 4 = Permissions
PermissionsOkToCopy
    toEnum 8 = Permissions
PermissionsOkToAddNotes
    toEnum 16 = Permissions
PermissionsOkToFillForm
    toEnum 32 = Permissions
PermissionsOkToExtractContents
    toEnum 64 = Permissions
PermissionsOkToAssemble
    toEnum 128 = Permissions
PermissionsOkToPrintHighResolution
    toEnum 255 = Permissions
PermissionsFull
    toEnum k :: Int
k = Int -> Permissions
AnotherPermissions Int
k

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

foreign import ccall "poppler_permissions_get_type" c_poppler_permissions_get_type :: 
    IO GType

instance BoxedFlags Permissions where
    boxedFlagsType :: Proxy Permissions -> IO GType
boxedFlagsType _ = IO GType
c_poppler_permissions_get_type

instance IsGFlag Permissions

-- Flags FindFlags
-- | Flags using while searching text in a page
-- 
-- /Since: 0.22/
data FindFlags = 
      FindFlagsDefault
    -- ^ use default search settings
    | FindFlagsCaseSensitive
    -- ^ do case sensitive search
    | FindFlagsBackwards
    -- ^ search backwards
    | FindFlagsWholeWordsOnly
    -- ^ search only whole words
    | FindFlagsIgnoreDiacritics
    -- ^ do diacritics insensitive search,
    -- i.e. ignore accents, umlauts, diaeresis,etc. while matching. This
    -- option will be ignored if the search term is not pure ascii. Since 0.73.
    | AnotherFindFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> FindFlags -> ShowS
[FindFlags] -> ShowS
FindFlags -> String
(Int -> FindFlags -> ShowS)
-> (FindFlags -> String)
-> ([FindFlags] -> ShowS)
-> Show FindFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FindFlags] -> ShowS
$cshowList :: [FindFlags] -> ShowS
show :: FindFlags -> String
$cshow :: FindFlags -> String
showsPrec :: Int -> FindFlags -> ShowS
$cshowsPrec :: Int -> FindFlags -> ShowS
Show, FindFlags -> FindFlags -> Bool
(FindFlags -> FindFlags -> Bool)
-> (FindFlags -> FindFlags -> Bool) -> Eq FindFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FindFlags -> FindFlags -> Bool
$c/= :: FindFlags -> FindFlags -> Bool
== :: FindFlags -> FindFlags -> Bool
$c== :: FindFlags -> FindFlags -> Bool
Eq)

instance P.Enum FindFlags where
    fromEnum :: FindFlags -> Int
fromEnum FindFlagsDefault = 0
    fromEnum FindFlagsCaseSensitive = 1
    fromEnum FindFlagsBackwards = 2
    fromEnum FindFlagsWholeWordsOnly = 4
    fromEnum FindFlagsIgnoreDiacritics = 8
    fromEnum (AnotherFindFlags k :: Int
k) = Int
k

    toEnum :: Int -> FindFlags
toEnum 0 = FindFlags
FindFlagsDefault
    toEnum 1 = FindFlags
FindFlagsCaseSensitive
    toEnum 2 = FindFlags
FindFlagsBackwards
    toEnum 4 = FindFlags
FindFlagsWholeWordsOnly
    toEnum 8 = FindFlags
FindFlagsIgnoreDiacritics
    toEnum k :: Int
k = Int -> FindFlags
AnotherFindFlags Int
k

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

foreign import ccall "poppler_find_flags_get_type" c_poppler_find_flags_get_type :: 
    IO GType

instance BoxedFlags FindFlags where
    boxedFlagsType :: Proxy FindFlags -> IO GType
boxedFlagsType _ = IO GType
c_poppler_find_flags_get_type

instance IsGFlag FindFlags

-- Flags AnnotFlag
-- | /No description available in the introspection data./
data AnnotFlag = 
      AnnotFlagUnknown
    -- ^ /No description available in the introspection data./
    | AnnotFlagInvisible
    -- ^ /No description available in the introspection data./
    | AnnotFlagHidden
    -- ^ /No description available in the introspection data./
    | AnnotFlagPrint
    -- ^ /No description available in the introspection data./
    | AnnotFlagNoZoom
    -- ^ /No description available in the introspection data./
    | AnnotFlagNoRotate
    -- ^ /No description available in the introspection data./
    | AnnotFlagNoView
    -- ^ /No description available in the introspection data./
    | AnnotFlagReadOnly
    -- ^ /No description available in the introspection data./
    | AnnotFlagLocked
    -- ^ /No description available in the introspection data./
    | AnnotFlagToggleNoView
    -- ^ /No description available in the introspection data./
    | AnnotFlagLockedContents
    -- ^ /No description available in the introspection data./
    | AnotherAnnotFlag Int
    -- ^ Catch-all for unknown values
    deriving (Int -> AnnotFlag -> ShowS
[AnnotFlag] -> ShowS
AnnotFlag -> String
(Int -> AnnotFlag -> ShowS)
-> (AnnotFlag -> String)
-> ([AnnotFlag] -> ShowS)
-> Show AnnotFlag
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AnnotFlag] -> ShowS
$cshowList :: [AnnotFlag] -> ShowS
show :: AnnotFlag -> String
$cshow :: AnnotFlag -> String
showsPrec :: Int -> AnnotFlag -> ShowS
$cshowsPrec :: Int -> AnnotFlag -> ShowS
Show, AnnotFlag -> AnnotFlag -> Bool
(AnnotFlag -> AnnotFlag -> Bool)
-> (AnnotFlag -> AnnotFlag -> Bool) -> Eq AnnotFlag
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AnnotFlag -> AnnotFlag -> Bool
$c/= :: AnnotFlag -> AnnotFlag -> Bool
== :: AnnotFlag -> AnnotFlag -> Bool
$c== :: AnnotFlag -> AnnotFlag -> Bool
Eq)

instance P.Enum AnnotFlag where
    fromEnum :: AnnotFlag -> Int
fromEnum AnnotFlagUnknown = 0
    fromEnum AnnotFlagInvisible = 1
    fromEnum AnnotFlagHidden = 2
    fromEnum AnnotFlagPrint = 4
    fromEnum AnnotFlagNoZoom = 8
    fromEnum AnnotFlagNoRotate = 16
    fromEnum AnnotFlagNoView = 32
    fromEnum AnnotFlagReadOnly = 64
    fromEnum AnnotFlagLocked = 128
    fromEnum AnnotFlagToggleNoView = 256
    fromEnum AnnotFlagLockedContents = 512
    fromEnum (AnotherAnnotFlag k :: Int
k) = Int
k

    toEnum :: Int -> AnnotFlag
toEnum 0 = AnnotFlag
AnnotFlagUnknown
    toEnum 1 = AnnotFlag
AnnotFlagInvisible
    toEnum 2 = AnnotFlag
AnnotFlagHidden
    toEnum 4 = AnnotFlag
AnnotFlagPrint
    toEnum 8 = AnnotFlag
AnnotFlagNoZoom
    toEnum 16 = AnnotFlag
AnnotFlagNoRotate
    toEnum 32 = AnnotFlag
AnnotFlagNoView
    toEnum 64 = AnnotFlag
AnnotFlagReadOnly
    toEnum 128 = AnnotFlag
AnnotFlagLocked
    toEnum 256 = AnnotFlag
AnnotFlagToggleNoView
    toEnum 512 = AnnotFlag
AnnotFlagLockedContents
    toEnum k :: Int
k = Int -> AnnotFlag
AnotherAnnotFlag Int
k

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

foreign import ccall "poppler_annot_flag_get_type" c_poppler_annot_flag_get_type :: 
    IO GType

instance BoxedFlags AnnotFlag where
    boxedFlagsType :: Proxy AnnotFlag -> IO GType
boxedFlagsType _ = IO GType
c_poppler_annot_flag_get_type

instance IsGFlag AnnotFlag