-- | 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.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL


-- 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 ViewerPreferences
ViewerPreferencesUnset = Int
0
    fromEnum ViewerPreferences
ViewerPreferencesHideToolbar = Int
1
    fromEnum ViewerPreferences
ViewerPreferencesHideMenubar = Int
2
    fromEnum ViewerPreferences
ViewerPreferencesHideWindowui = Int
4
    fromEnum ViewerPreferences
ViewerPreferencesFitWindow = Int
8
    fromEnum ViewerPreferences
ViewerPreferencesCenterWindow = Int
16
    fromEnum ViewerPreferences
ViewerPreferencesDisplayDocTitle = Int
32
    fromEnum ViewerPreferences
ViewerPreferencesDirectionRtl = Int
64
    fromEnum (AnotherViewerPreferences Int
k) = Int
k

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

instance P.Ord ViewerPreferences where
    compare :: ViewerPreferences -> ViewerPreferences -> Ordering
compare ViewerPreferences
a 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)

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

foreign import ccall "poppler_viewer_preferences_get_type" c_poppler_viewer_preferences_get_type :: 
    IO GType

instance B.Types.TypedObject ViewerPreferences where
    glibType :: IO GType
glibType = IO GType
c_poppler_viewer_preferences_get_type

instance B.Types.BoxedFlags ViewerPreferences

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 StructureGetTextFlags
StructureGetTextFlagsNone = Int
0
    fromEnum StructureGetTextFlags
StructureGetTextFlagsRecursive = Int
1
    fromEnum (AnotherStructureGetTextFlags Int
k) = Int
k

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

instance P.Ord StructureGetTextFlags where
    compare :: StructureGetTextFlags -> StructureGetTextFlags -> Ordering
compare StructureGetTextFlags
a 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)

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

foreign import ccall "poppler_structure_get_text_flags_get_type" c_poppler_structure_get_text_flags_get_type :: 
    IO GType

instance B.Types.TypedObject StructureGetTextFlags where
    glibType :: IO GType
glibType = IO GType
c_poppler_structure_get_text_flags_get_type

instance B.Types.BoxedFlags StructureGetTextFlags

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 PrintFlags
PrintFlagsDocument = Int
0
    fromEnum PrintFlags
PrintFlagsMarkupAnnots = Int
1
    fromEnum PrintFlags
PrintFlagsStampAnnotsOnly = Int
2
    fromEnum PrintFlags
PrintFlagsAll = Int
1
    fromEnum (AnotherPrintFlags Int
k) = Int
k

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

instance P.Ord PrintFlags where
    compare :: PrintFlags -> PrintFlags -> Ordering
compare PrintFlags
a 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)

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

foreign import ccall "poppler_print_flags_get_type" c_poppler_print_flags_get_type :: 
    IO GType

instance B.Types.TypedObject PrintFlags where
    glibType :: IO GType
glibType = IO GType
c_poppler_print_flags_get_type

instance B.Types.BoxedFlags PrintFlags

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 Permissions
PermissionsOkToPrint = Int
1
    fromEnum Permissions
PermissionsOkToModify = Int
2
    fromEnum Permissions
PermissionsOkToCopy = Int
4
    fromEnum Permissions
PermissionsOkToAddNotes = Int
8
    fromEnum Permissions
PermissionsOkToFillForm = Int
16
    fromEnum Permissions
PermissionsOkToExtractContents = Int
32
    fromEnum Permissions
PermissionsOkToAssemble = Int
64
    fromEnum Permissions
PermissionsOkToPrintHighResolution = Int
128
    fromEnum Permissions
PermissionsFull = Int
255
    fromEnum (AnotherPermissions Int
k) = Int
k

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

instance P.Ord Permissions where
    compare :: Permissions -> Permissions -> Ordering
compare Permissions
a 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)

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

foreign import ccall "poppler_permissions_get_type" c_poppler_permissions_get_type :: 
    IO GType

instance B.Types.TypedObject Permissions where
    glibType :: IO GType
glibType = IO GType
c_poppler_permissions_get_type

instance B.Types.BoxedFlags Permissions

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 FindFlags
FindFlagsDefault = Int
0
    fromEnum FindFlags
FindFlagsCaseSensitive = Int
1
    fromEnum FindFlags
FindFlagsBackwards = Int
2
    fromEnum FindFlags
FindFlagsWholeWordsOnly = Int
4
    fromEnum FindFlags
FindFlagsIgnoreDiacritics = Int
8
    fromEnum (AnotherFindFlags Int
k) = Int
k

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

instance P.Ord FindFlags where
    compare :: FindFlags -> FindFlags -> Ordering
compare FindFlags
a 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)

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

foreign import ccall "poppler_find_flags_get_type" c_poppler_find_flags_get_type :: 
    IO GType

instance B.Types.TypedObject FindFlags where
    glibType :: IO GType
glibType = IO GType
c_poppler_find_flags_get_type

instance B.Types.BoxedFlags FindFlags

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 AnnotFlag
AnnotFlagUnknown = Int
0
    fromEnum AnnotFlag
AnnotFlagInvisible = Int
1
    fromEnum AnnotFlag
AnnotFlagHidden = Int
2
    fromEnum AnnotFlag
AnnotFlagPrint = Int
4
    fromEnum AnnotFlag
AnnotFlagNoZoom = Int
8
    fromEnum AnnotFlag
AnnotFlagNoRotate = Int
16
    fromEnum AnnotFlag
AnnotFlagNoView = Int
32
    fromEnum AnnotFlag
AnnotFlagReadOnly = Int
64
    fromEnum AnnotFlag
AnnotFlagLocked = Int
128
    fromEnum AnnotFlag
AnnotFlagToggleNoView = Int
256
    fromEnum AnnotFlag
AnnotFlagLockedContents = Int
512
    fromEnum (AnotherAnnotFlag Int
k) = Int
k

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

instance P.Ord AnnotFlag where
    compare :: AnnotFlag -> AnnotFlag -> Ordering
compare AnnotFlag
a 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)

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

foreign import ccall "poppler_annot_flag_get_type" c_poppler_annot_flag_get_type :: 
    IO GType

instance B.Types.TypedObject AnnotFlag where
    glibType :: IO GType
glibType = IO GType
c_poppler_annot_flag_get_type

instance B.Types.BoxedFlags AnnotFlag

instance IsGFlag AnnotFlag