-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- 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.Gtk.Flags
    ( 

 -- * Flags


-- ** ApplicationInhibitFlags #flag:ApplicationInhibitFlags#

    ApplicationInhibitFlags(..)             ,


-- ** BuilderClosureFlags #flag:BuilderClosureFlags#

    BuilderClosureFlags(..)                 ,


-- ** CellRendererState #flag:CellRendererState#

    CellRendererState(..)                   ,


-- ** DebugFlags #flag:DebugFlags#

    DebugFlags(..)                          ,


-- ** DialogFlags #flag:DialogFlags#

    DialogFlags(..)                         ,


-- ** EventControllerScrollFlags #flag:EventControllerScrollFlags#

    EventControllerScrollFlags(..)          ,


-- ** FontChooserLevel #flag:FontChooserLevel#

    FontChooserLevel(..)                    ,


-- ** IconLookupFlags #flag:IconLookupFlags#

    IconLookupFlags(..)                     ,


-- ** InputHints #flag:InputHints#

    InputHints(..)                          ,


-- ** PickFlags #flag:PickFlags#

    PickFlags(..)                           ,


-- ** PopoverMenuFlags #flag:PopoverMenuFlags#

    PopoverMenuFlags(..)                    ,


-- ** PrintCapabilities #flag:PrintCapabilities#

    PrintCapabilities(..)                   ,


-- ** ShortcutActionFlags #flag:ShortcutActionFlags#

    ShortcutActionFlags(..)                 ,


-- ** StateFlags #flag:StateFlags#

    StateFlags(..)                          ,


-- ** StyleContextPrintFlags #flag:StyleContextPrintFlags#

    StyleContextPrintFlags(..)              ,


-- ** TextSearchFlags #flag:TextSearchFlags#

    TextSearchFlags(..)                     ,


-- ** TreeModelFlags #flag:TreeModelFlags#

    TreeModelFlags(..)                      ,




    ) where

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

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
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.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R


-- Flags TreeModelFlags
-- | These flags indicate various properties of a @GtkTreeModel@.
-- 
-- They are returned by 'GI.Gtk.Interfaces.TreeModel.treeModelGetFlags', and must be
-- static for the lifetime of the object. A more complete description
-- of 'GI.Gtk.Flags.TreeModelFlagsItersPersist' can be found in the overview of
-- this section.
data TreeModelFlags = 
      TreeModelFlagsItersPersist
    -- ^ iterators survive all signals
    --   emitted by the tree
    | TreeModelFlagsListOnly
    -- ^ the model is a list only, and never
    --   has children
    | AnotherTreeModelFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> TreeModelFlags -> ShowS
[TreeModelFlags] -> ShowS
TreeModelFlags -> String
(Int -> TreeModelFlags -> ShowS)
-> (TreeModelFlags -> String)
-> ([TreeModelFlags] -> ShowS)
-> Show TreeModelFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TreeModelFlags -> ShowS
showsPrec :: Int -> TreeModelFlags -> ShowS
$cshow :: TreeModelFlags -> String
show :: TreeModelFlags -> String
$cshowList :: [TreeModelFlags] -> ShowS
showList :: [TreeModelFlags] -> ShowS
Show, TreeModelFlags -> TreeModelFlags -> Bool
(TreeModelFlags -> TreeModelFlags -> Bool)
-> (TreeModelFlags -> TreeModelFlags -> Bool) -> Eq TreeModelFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TreeModelFlags -> TreeModelFlags -> Bool
== :: TreeModelFlags -> TreeModelFlags -> Bool
$c/= :: TreeModelFlags -> TreeModelFlags -> Bool
/= :: TreeModelFlags -> TreeModelFlags -> Bool
Eq)

instance P.Enum TreeModelFlags where
    fromEnum :: TreeModelFlags -> Int
fromEnum TreeModelFlags
TreeModelFlagsItersPersist = Int
1
    fromEnum TreeModelFlags
TreeModelFlagsListOnly = Int
2
    fromEnum (AnotherTreeModelFlags Int
k) = Int
k

    toEnum :: Int -> TreeModelFlags
toEnum Int
1 = TreeModelFlags
TreeModelFlagsItersPersist
    toEnum Int
2 = TreeModelFlags
TreeModelFlagsListOnly
    toEnum Int
k = Int -> TreeModelFlags
AnotherTreeModelFlags Int
k

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

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

foreign import ccall "gtk_tree_model_flags_get_type" c_gtk_tree_model_flags_get_type :: 
    IO GType

instance B.Types.TypedObject TreeModelFlags where
    glibType :: IO GType
glibType = IO GType
c_gtk_tree_model_flags_get_type

instance B.Types.BoxedFlags TreeModelFlags

instance IsGFlag TreeModelFlags

-- Flags TextSearchFlags
-- | Flags affecting how a search is done.
-- 
-- If neither 'GI.Gtk.Flags.TextSearchFlagsVisibleOnly' nor 'GI.Gtk.Flags.TextSearchFlagsTextOnly' are
-- enabled, the match must be exact; the special 0xFFFC character will match
-- embedded paintables or child widgets.
data TextSearchFlags = 
      TextSearchFlagsVisibleOnly
    -- ^ Search only visible data. A search match may
    -- have invisible text interspersed.
    | TextSearchFlagsTextOnly
    -- ^ Search only text. A match may have paintables or
    -- child widgets mixed inside the matched range.
    | TextSearchFlagsCaseInsensitive
    -- ^ The text will be matched regardless of
    -- what case it is in.
    | AnotherTextSearchFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> TextSearchFlags -> ShowS
[TextSearchFlags] -> ShowS
TextSearchFlags -> String
(Int -> TextSearchFlags -> ShowS)
-> (TextSearchFlags -> String)
-> ([TextSearchFlags] -> ShowS)
-> Show TextSearchFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TextSearchFlags -> ShowS
showsPrec :: Int -> TextSearchFlags -> ShowS
$cshow :: TextSearchFlags -> String
show :: TextSearchFlags -> String
$cshowList :: [TextSearchFlags] -> ShowS
showList :: [TextSearchFlags] -> ShowS
Show, TextSearchFlags -> TextSearchFlags -> Bool
(TextSearchFlags -> TextSearchFlags -> Bool)
-> (TextSearchFlags -> TextSearchFlags -> Bool)
-> Eq TextSearchFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TextSearchFlags -> TextSearchFlags -> Bool
== :: TextSearchFlags -> TextSearchFlags -> Bool
$c/= :: TextSearchFlags -> TextSearchFlags -> Bool
/= :: TextSearchFlags -> TextSearchFlags -> Bool
Eq)

instance P.Enum TextSearchFlags where
    fromEnum :: TextSearchFlags -> Int
fromEnum TextSearchFlags
TextSearchFlagsVisibleOnly = Int
1
    fromEnum TextSearchFlags
TextSearchFlagsTextOnly = Int
2
    fromEnum TextSearchFlags
TextSearchFlagsCaseInsensitive = Int
4
    fromEnum (AnotherTextSearchFlags Int
k) = Int
k

    toEnum :: Int -> TextSearchFlags
toEnum Int
1 = TextSearchFlags
TextSearchFlagsVisibleOnly
    toEnum Int
2 = TextSearchFlags
TextSearchFlagsTextOnly
    toEnum Int
4 = TextSearchFlags
TextSearchFlagsCaseInsensitive
    toEnum Int
k = Int -> TextSearchFlags
AnotherTextSearchFlags Int
k

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

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

foreign import ccall "gtk_text_search_flags_get_type" c_gtk_text_search_flags_get_type :: 
    IO GType

instance B.Types.TypedObject TextSearchFlags where
    glibType :: IO GType
glibType = IO GType
c_gtk_text_search_flags_get_type

instance B.Types.BoxedFlags TextSearchFlags

instance IsGFlag TextSearchFlags

-- Flags StyleContextPrintFlags
-- | Flags that modify the behavior of 'GI.Gtk.Objects.StyleContext.styleContextToString'.
-- 
-- New values may be added to this enumeration.
data StyleContextPrintFlags = 
      StyleContextPrintFlagsNone
    -- ^ Default value.
    | StyleContextPrintFlagsRecurse
    -- ^ Print the entire tree of
    --   CSS nodes starting at the style context\'s node
    | StyleContextPrintFlagsShowStyle
    -- ^ Show the values of the
    --   CSS properties for each node
    | StyleContextPrintFlagsShowChange
    -- ^ Show information about
    --   what changes affect the styles
    | AnotherStyleContextPrintFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> StyleContextPrintFlags -> ShowS
[StyleContextPrintFlags] -> ShowS
StyleContextPrintFlags -> String
(Int -> StyleContextPrintFlags -> ShowS)
-> (StyleContextPrintFlags -> String)
-> ([StyleContextPrintFlags] -> ShowS)
-> Show StyleContextPrintFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> StyleContextPrintFlags -> ShowS
showsPrec :: Int -> StyleContextPrintFlags -> ShowS
$cshow :: StyleContextPrintFlags -> String
show :: StyleContextPrintFlags -> String
$cshowList :: [StyleContextPrintFlags] -> ShowS
showList :: [StyleContextPrintFlags] -> ShowS
Show, StyleContextPrintFlags -> StyleContextPrintFlags -> Bool
(StyleContextPrintFlags -> StyleContextPrintFlags -> Bool)
-> (StyleContextPrintFlags -> StyleContextPrintFlags -> Bool)
-> Eq StyleContextPrintFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: StyleContextPrintFlags -> StyleContextPrintFlags -> Bool
== :: StyleContextPrintFlags -> StyleContextPrintFlags -> Bool
$c/= :: StyleContextPrintFlags -> StyleContextPrintFlags -> Bool
/= :: StyleContextPrintFlags -> StyleContextPrintFlags -> Bool
Eq)

instance P.Enum StyleContextPrintFlags where
    fromEnum :: StyleContextPrintFlags -> Int
fromEnum StyleContextPrintFlags
StyleContextPrintFlagsNone = Int
0
    fromEnum StyleContextPrintFlags
StyleContextPrintFlagsRecurse = Int
1
    fromEnum StyleContextPrintFlags
StyleContextPrintFlagsShowStyle = Int
2
    fromEnum StyleContextPrintFlags
StyleContextPrintFlagsShowChange = Int
4
    fromEnum (AnotherStyleContextPrintFlags Int
k) = Int
k

    toEnum :: Int -> StyleContextPrintFlags
toEnum Int
0 = StyleContextPrintFlags
StyleContextPrintFlagsNone
    toEnum Int
1 = StyleContextPrintFlags
StyleContextPrintFlagsRecurse
    toEnum Int
2 = StyleContextPrintFlags
StyleContextPrintFlagsShowStyle
    toEnum Int
4 = StyleContextPrintFlags
StyleContextPrintFlagsShowChange
    toEnum Int
k = Int -> StyleContextPrintFlags
AnotherStyleContextPrintFlags Int
k

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

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

foreign import ccall "gtk_style_context_print_flags_get_type" c_gtk_style_context_print_flags_get_type :: 
    IO GType

instance B.Types.TypedObject StyleContextPrintFlags where
    glibType :: IO GType
glibType = IO GType
c_gtk_style_context_print_flags_get_type

instance B.Types.BoxedFlags StyleContextPrintFlags

instance IsGFlag StyleContextPrintFlags

-- Flags StateFlags
-- | Describes a widget state.
-- 
-- Widget states are used to match the widget against CSS pseudo-classes.
-- Note that GTK extends the regular CSS classes and sometimes uses
-- different names.
data StateFlags = 
      StateFlagsNormal
    -- ^ State during normal operation
    | StateFlagsActive
    -- ^ Widget is active
    | StateFlagsPrelight
    -- ^ Widget has a mouse pointer over it
    | StateFlagsSelected
    -- ^ Widget is selected
    | StateFlagsInsensitive
    -- ^ Widget is insensitive
    | StateFlagsInconsistent
    -- ^ Widget is inconsistent
    | StateFlagsFocused
    -- ^ Widget has the keyboard focus
    | StateFlagsBackdrop
    -- ^ Widget is in a background toplevel window
    | StateFlagsDirLtr
    -- ^ Widget is in left-to-right text direction
    | StateFlagsDirRtl
    -- ^ Widget is in right-to-left text direction
    | StateFlagsLink
    -- ^ Widget is a link
    | StateFlagsVisited
    -- ^ The location the widget points to has already been visited
    | StateFlagsChecked
    -- ^ Widget is checked
    | StateFlagsDropActive
    -- ^ Widget is highlighted as a drop target for DND
    | StateFlagsFocusVisible
    -- ^ Widget has the visible focus
    | StateFlagsFocusWithin
    -- ^ Widget contains the keyboard focus
    | AnotherStateFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> StateFlags -> ShowS
[StateFlags] -> ShowS
StateFlags -> String
(Int -> StateFlags -> ShowS)
-> (StateFlags -> String)
-> ([StateFlags] -> ShowS)
-> Show StateFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> StateFlags -> ShowS
showsPrec :: Int -> StateFlags -> ShowS
$cshow :: StateFlags -> String
show :: StateFlags -> String
$cshowList :: [StateFlags] -> ShowS
showList :: [StateFlags] -> ShowS
Show, StateFlags -> StateFlags -> Bool
(StateFlags -> StateFlags -> Bool)
-> (StateFlags -> StateFlags -> Bool) -> Eq StateFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: StateFlags -> StateFlags -> Bool
== :: StateFlags -> StateFlags -> Bool
$c/= :: StateFlags -> StateFlags -> Bool
/= :: StateFlags -> StateFlags -> Bool
Eq)

instance P.Enum StateFlags where
    fromEnum :: StateFlags -> Int
fromEnum StateFlags
StateFlagsNormal = Int
0
    fromEnum StateFlags
StateFlagsActive = Int
1
    fromEnum StateFlags
StateFlagsPrelight = Int
2
    fromEnum StateFlags
StateFlagsSelected = Int
4
    fromEnum StateFlags
StateFlagsInsensitive = Int
8
    fromEnum StateFlags
StateFlagsInconsistent = Int
16
    fromEnum StateFlags
StateFlagsFocused = Int
32
    fromEnum StateFlags
StateFlagsBackdrop = Int
64
    fromEnum StateFlags
StateFlagsDirLtr = Int
128
    fromEnum StateFlags
StateFlagsDirRtl = Int
256
    fromEnum StateFlags
StateFlagsLink = Int
512
    fromEnum StateFlags
StateFlagsVisited = Int
1024
    fromEnum StateFlags
StateFlagsChecked = Int
2048
    fromEnum StateFlags
StateFlagsDropActive = Int
4096
    fromEnum StateFlags
StateFlagsFocusVisible = Int
8192
    fromEnum StateFlags
StateFlagsFocusWithin = Int
16384
    fromEnum (AnotherStateFlags Int
k) = Int
k

    toEnum :: Int -> StateFlags
toEnum Int
0 = StateFlags
StateFlagsNormal
    toEnum Int
1 = StateFlags
StateFlagsActive
    toEnum Int
2 = StateFlags
StateFlagsPrelight
    toEnum Int
4 = StateFlags
StateFlagsSelected
    toEnum Int
8 = StateFlags
StateFlagsInsensitive
    toEnum Int
16 = StateFlags
StateFlagsInconsistent
    toEnum Int
32 = StateFlags
StateFlagsFocused
    toEnum Int
64 = StateFlags
StateFlagsBackdrop
    toEnum Int
128 = StateFlags
StateFlagsDirLtr
    toEnum Int
256 = StateFlags
StateFlagsDirRtl
    toEnum Int
512 = StateFlags
StateFlagsLink
    toEnum Int
1024 = StateFlags
StateFlagsVisited
    toEnum Int
2048 = StateFlags
StateFlagsChecked
    toEnum Int
4096 = StateFlags
StateFlagsDropActive
    toEnum Int
8192 = StateFlags
StateFlagsFocusVisible
    toEnum Int
16384 = StateFlags
StateFlagsFocusWithin
    toEnum Int
k = Int -> StateFlags
AnotherStateFlags Int
k

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

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

foreign import ccall "gtk_state_flags_get_type" c_gtk_state_flags_get_type :: 
    IO GType

instance B.Types.TypedObject StateFlags where
    glibType :: IO GType
glibType = IO GType
c_gtk_state_flags_get_type

instance B.Types.BoxedFlags StateFlags

instance IsGFlag StateFlags

-- Flags ShortcutActionFlags
-- | List of flags that can be passed to action activation.
-- 
-- More flags may be added in the future.
data ShortcutActionFlags = 
      ShortcutActionFlagsExclusive
    -- ^ The action is the only
    --   action that can be activated. If this flag is not set,
    --   a future activation may select a different action.
    | AnotherShortcutActionFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ShortcutActionFlags -> ShowS
[ShortcutActionFlags] -> ShowS
ShortcutActionFlags -> String
(Int -> ShortcutActionFlags -> ShowS)
-> (ShortcutActionFlags -> String)
-> ([ShortcutActionFlags] -> ShowS)
-> Show ShortcutActionFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ShortcutActionFlags -> ShowS
showsPrec :: Int -> ShortcutActionFlags -> ShowS
$cshow :: ShortcutActionFlags -> String
show :: ShortcutActionFlags -> String
$cshowList :: [ShortcutActionFlags] -> ShowS
showList :: [ShortcutActionFlags] -> ShowS
Show, ShortcutActionFlags -> ShortcutActionFlags -> Bool
(ShortcutActionFlags -> ShortcutActionFlags -> Bool)
-> (ShortcutActionFlags -> ShortcutActionFlags -> Bool)
-> Eq ShortcutActionFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ShortcutActionFlags -> ShortcutActionFlags -> Bool
== :: ShortcutActionFlags -> ShortcutActionFlags -> Bool
$c/= :: ShortcutActionFlags -> ShortcutActionFlags -> Bool
/= :: ShortcutActionFlags -> ShortcutActionFlags -> Bool
Eq)

instance P.Enum ShortcutActionFlags where
    fromEnum :: ShortcutActionFlags -> Int
fromEnum ShortcutActionFlags
ShortcutActionFlagsExclusive = Int
1
    fromEnum (AnotherShortcutActionFlags Int
k) = Int
k

    toEnum :: Int -> ShortcutActionFlags
toEnum Int
1 = ShortcutActionFlags
ShortcutActionFlagsExclusive
    toEnum Int
k = Int -> ShortcutActionFlags
AnotherShortcutActionFlags Int
k

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

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

foreign import ccall "gtk_shortcut_action_flags_get_type" c_gtk_shortcut_action_flags_get_type :: 
    IO GType

instance B.Types.TypedObject ShortcutActionFlags where
    glibType :: IO GType
glibType = IO GType
c_gtk_shortcut_action_flags_get_type

instance B.Types.BoxedFlags ShortcutActionFlags

instance IsGFlag ShortcutActionFlags

-- Flags PrintCapabilities
-- | Specifies which features the print dialog should offer.
-- 
-- If neither 'GI.Gtk.Flags.PrintCapabilitiesGeneratePdf' nor
-- 'GI.Gtk.Flags.PrintCapabilitiesGeneratePs' is specified, GTK assumes that all
-- formats are supported.
data PrintCapabilities = 
      PrintCapabilitiesPageSet
    -- ^ Print dialog will offer printing even\/odd pages.
    | PrintCapabilitiesCopies
    -- ^ Print dialog will allow to print multiple copies.
    | PrintCapabilitiesCollate
    -- ^ Print dialog will allow to collate multiple copies.
    | PrintCapabilitiesReverse
    -- ^ Print dialog will allow to print pages in reverse order.
    | PrintCapabilitiesScale
    -- ^ Print dialog will allow to scale the output.
    | PrintCapabilitiesGeneratePdf
    -- ^ The program will send the document to
    --   the printer in PDF format
    | PrintCapabilitiesGeneratePs
    -- ^ The program will send the document to
    --   the printer in Postscript format
    | PrintCapabilitiesPreview
    -- ^ Print dialog will offer a preview
    | PrintCapabilitiesNumberUp
    -- ^ Print dialog will offer printing multiple
    --   pages per sheet
    | PrintCapabilitiesNumberUpLayout
    -- ^ Print dialog will allow to rearrange
    --   pages when printing multiple pages per sheet
    | AnotherPrintCapabilities Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PrintCapabilities -> ShowS
[PrintCapabilities] -> ShowS
PrintCapabilities -> String
(Int -> PrintCapabilities -> ShowS)
-> (PrintCapabilities -> String)
-> ([PrintCapabilities] -> ShowS)
-> Show PrintCapabilities
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PrintCapabilities -> ShowS
showsPrec :: Int -> PrintCapabilities -> ShowS
$cshow :: PrintCapabilities -> String
show :: PrintCapabilities -> String
$cshowList :: [PrintCapabilities] -> ShowS
showList :: [PrintCapabilities] -> ShowS
Show, PrintCapabilities -> PrintCapabilities -> Bool
(PrintCapabilities -> PrintCapabilities -> Bool)
-> (PrintCapabilities -> PrintCapabilities -> Bool)
-> Eq PrintCapabilities
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PrintCapabilities -> PrintCapabilities -> Bool
== :: PrintCapabilities -> PrintCapabilities -> Bool
$c/= :: PrintCapabilities -> PrintCapabilities -> Bool
/= :: PrintCapabilities -> PrintCapabilities -> Bool
Eq)

instance P.Enum PrintCapabilities where
    fromEnum :: PrintCapabilities -> Int
fromEnum PrintCapabilities
PrintCapabilitiesPageSet = Int
1
    fromEnum PrintCapabilities
PrintCapabilitiesCopies = Int
2
    fromEnum PrintCapabilities
PrintCapabilitiesCollate = Int
4
    fromEnum PrintCapabilities
PrintCapabilitiesReverse = Int
8
    fromEnum PrintCapabilities
PrintCapabilitiesScale = Int
16
    fromEnum PrintCapabilities
PrintCapabilitiesGeneratePdf = Int
32
    fromEnum PrintCapabilities
PrintCapabilitiesGeneratePs = Int
64
    fromEnum PrintCapabilities
PrintCapabilitiesPreview = Int
128
    fromEnum PrintCapabilities
PrintCapabilitiesNumberUp = Int
256
    fromEnum PrintCapabilities
PrintCapabilitiesNumberUpLayout = Int
512
    fromEnum (AnotherPrintCapabilities Int
k) = Int
k

    toEnum :: Int -> PrintCapabilities
toEnum Int
1 = PrintCapabilities
PrintCapabilitiesPageSet
    toEnum Int
2 = PrintCapabilities
PrintCapabilitiesCopies
    toEnum Int
4 = PrintCapabilities
PrintCapabilitiesCollate
    toEnum Int
8 = PrintCapabilities
PrintCapabilitiesReverse
    toEnum Int
16 = PrintCapabilities
PrintCapabilitiesScale
    toEnum Int
32 = PrintCapabilities
PrintCapabilitiesGeneratePdf
    toEnum Int
64 = PrintCapabilities
PrintCapabilitiesGeneratePs
    toEnum Int
128 = PrintCapabilities
PrintCapabilitiesPreview
    toEnum Int
256 = PrintCapabilities
PrintCapabilitiesNumberUp
    toEnum Int
512 = PrintCapabilities
PrintCapabilitiesNumberUpLayout
    toEnum Int
k = Int -> PrintCapabilities
AnotherPrintCapabilities Int
k

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

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

foreign import ccall "gtk_print_capabilities_get_type" c_gtk_print_capabilities_get_type :: 
    IO GType

instance B.Types.TypedObject PrintCapabilities where
    glibType :: IO GType
glibType = IO GType
c_gtk_print_capabilities_get_type

instance B.Types.BoxedFlags PrintCapabilities

instance IsGFlag PrintCapabilities

-- Flags PopoverMenuFlags
-- | Flags that affect how popover menus are created from
-- a menu model.
data PopoverMenuFlags = 
      PopoverMenuFlagsNested
    -- ^ Create submenus as nested
    --    popovers. Without this flag, submenus are created as
    --    sliding pages that replace the main menu.
    | AnotherPopoverMenuFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PopoverMenuFlags -> ShowS
[PopoverMenuFlags] -> ShowS
PopoverMenuFlags -> String
(Int -> PopoverMenuFlags -> ShowS)
-> (PopoverMenuFlags -> String)
-> ([PopoverMenuFlags] -> ShowS)
-> Show PopoverMenuFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PopoverMenuFlags -> ShowS
showsPrec :: Int -> PopoverMenuFlags -> ShowS
$cshow :: PopoverMenuFlags -> String
show :: PopoverMenuFlags -> String
$cshowList :: [PopoverMenuFlags] -> ShowS
showList :: [PopoverMenuFlags] -> ShowS
Show, PopoverMenuFlags -> PopoverMenuFlags -> Bool
(PopoverMenuFlags -> PopoverMenuFlags -> Bool)
-> (PopoverMenuFlags -> PopoverMenuFlags -> Bool)
-> Eq PopoverMenuFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PopoverMenuFlags -> PopoverMenuFlags -> Bool
== :: PopoverMenuFlags -> PopoverMenuFlags -> Bool
$c/= :: PopoverMenuFlags -> PopoverMenuFlags -> Bool
/= :: PopoverMenuFlags -> PopoverMenuFlags -> Bool
Eq)

instance P.Enum PopoverMenuFlags where
    fromEnum :: PopoverMenuFlags -> Int
fromEnum PopoverMenuFlags
PopoverMenuFlagsNested = Int
1
    fromEnum (AnotherPopoverMenuFlags Int
k) = Int
k

    toEnum :: Int -> PopoverMenuFlags
toEnum Int
1 = PopoverMenuFlags
PopoverMenuFlagsNested
    toEnum Int
k = Int -> PopoverMenuFlags
AnotherPopoverMenuFlags Int
k

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

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

foreign import ccall "gtk_popover_menu_flags_get_type" c_gtk_popover_menu_flags_get_type :: 
    IO GType

instance B.Types.TypedObject PopoverMenuFlags where
    glibType :: IO GType
glibType = IO GType
c_gtk_popover_menu_flags_get_type

instance B.Types.BoxedFlags PopoverMenuFlags

instance IsGFlag PopoverMenuFlags

-- Flags PickFlags
-- | Flags that influence the behavior of [method/@widget@/.pick].
data PickFlags = 
      PickFlagsDefault
    -- ^ The default behavior, include widgets that are receiving events
    | PickFlagsInsensitive
    -- ^ Include widgets that are insensitive
    | PickFlagsNonTargetable
    -- ^ Include widgets that are marked as non-targetable. See [property/@widget@/:can-target]
    | AnotherPickFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PickFlags -> ShowS
[PickFlags] -> ShowS
PickFlags -> String
(Int -> PickFlags -> ShowS)
-> (PickFlags -> String)
-> ([PickFlags] -> ShowS)
-> Show PickFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PickFlags -> ShowS
showsPrec :: Int -> PickFlags -> ShowS
$cshow :: PickFlags -> String
show :: PickFlags -> String
$cshowList :: [PickFlags] -> ShowS
showList :: [PickFlags] -> ShowS
Show, PickFlags -> PickFlags -> Bool
(PickFlags -> PickFlags -> Bool)
-> (PickFlags -> PickFlags -> Bool) -> Eq PickFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PickFlags -> PickFlags -> Bool
== :: PickFlags -> PickFlags -> Bool
$c/= :: PickFlags -> PickFlags -> Bool
/= :: PickFlags -> PickFlags -> Bool
Eq)

instance P.Enum PickFlags where
    fromEnum :: PickFlags -> Int
fromEnum PickFlags
PickFlagsDefault = Int
0
    fromEnum PickFlags
PickFlagsInsensitive = Int
1
    fromEnum PickFlags
PickFlagsNonTargetable = Int
2
    fromEnum (AnotherPickFlags Int
k) = Int
k

    toEnum :: Int -> PickFlags
toEnum Int
0 = PickFlags
PickFlagsDefault
    toEnum Int
1 = PickFlags
PickFlagsInsensitive
    toEnum Int
2 = PickFlags
PickFlagsNonTargetable
    toEnum Int
k = Int -> PickFlags
AnotherPickFlags Int
k

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

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

foreign import ccall "gtk_pick_flags_get_type" c_gtk_pick_flags_get_type :: 
    IO GType

instance B.Types.TypedObject PickFlags where
    glibType :: IO GType
glibType = IO GType
c_gtk_pick_flags_get_type

instance B.Types.BoxedFlags PickFlags

instance IsGFlag PickFlags

-- Flags InputHints
-- | Describes hints that might be taken into account by input methods
-- or applications.
-- 
-- Note that input methods may already tailor their behaviour according
-- to the [enum/@inputPurpose@/] of the entry.
-- 
-- Some common sense is expected when using these flags - mixing
-- 'GI.Gtk.Flags.InputHintsLowercase' with any of the uppercase hints makes no sense.
-- 
-- This enumeration may be extended in the future; input methods should
-- ignore unknown values.
data InputHints = 
      InputHintsNone
    -- ^ No special behaviour suggested
    | InputHintsSpellcheck
    -- ^ Suggest checking for typos
    | InputHintsNoSpellcheck
    -- ^ Suggest not checking for typos
    | InputHintsWordCompletion
    -- ^ Suggest word completion
    | InputHintsLowercase
    -- ^ Suggest to convert all text to lowercase
    | InputHintsUppercaseChars
    -- ^ Suggest to capitalize all text
    | InputHintsUppercaseWords
    -- ^ Suggest to capitalize the first
    --   character of each word
    | InputHintsUppercaseSentences
    -- ^ Suggest to capitalize the
    --   first word of each sentence
    | InputHintsInhibitOsk
    -- ^ Suggest to not show an onscreen keyboard
    --   (e.g for a calculator that already has all the keys).
    | InputHintsVerticalWriting
    -- ^ The text is vertical
    | InputHintsEmoji
    -- ^ Suggest offering Emoji support
    | InputHintsNoEmoji
    -- ^ Suggest not offering Emoji support
    | InputHintsPrivate
    -- ^ Request that the input method should not
    --    update personalized data (like typing history)
    | AnotherInputHints Int
    -- ^ Catch-all for unknown values
    deriving (Int -> InputHints -> ShowS
[InputHints] -> ShowS
InputHints -> String
(Int -> InputHints -> ShowS)
-> (InputHints -> String)
-> ([InputHints] -> ShowS)
-> Show InputHints
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> InputHints -> ShowS
showsPrec :: Int -> InputHints -> ShowS
$cshow :: InputHints -> String
show :: InputHints -> String
$cshowList :: [InputHints] -> ShowS
showList :: [InputHints] -> ShowS
Show, InputHints -> InputHints -> Bool
(InputHints -> InputHints -> Bool)
-> (InputHints -> InputHints -> Bool) -> Eq InputHints
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: InputHints -> InputHints -> Bool
== :: InputHints -> InputHints -> Bool
$c/= :: InputHints -> InputHints -> Bool
/= :: InputHints -> InputHints -> Bool
Eq)

instance P.Enum InputHints where
    fromEnum :: InputHints -> Int
fromEnum InputHints
InputHintsNone = Int
0
    fromEnum InputHints
InputHintsSpellcheck = Int
1
    fromEnum InputHints
InputHintsNoSpellcheck = Int
2
    fromEnum InputHints
InputHintsWordCompletion = Int
4
    fromEnum InputHints
InputHintsLowercase = Int
8
    fromEnum InputHints
InputHintsUppercaseChars = Int
16
    fromEnum InputHints
InputHintsUppercaseWords = Int
32
    fromEnum InputHints
InputHintsUppercaseSentences = Int
64
    fromEnum InputHints
InputHintsInhibitOsk = Int
128
    fromEnum InputHints
InputHintsVerticalWriting = Int
256
    fromEnum InputHints
InputHintsEmoji = Int
512
    fromEnum InputHints
InputHintsNoEmoji = Int
1024
    fromEnum InputHints
InputHintsPrivate = Int
2048
    fromEnum (AnotherInputHints Int
k) = Int
k

    toEnum :: Int -> InputHints
toEnum Int
0 = InputHints
InputHintsNone
    toEnum Int
1 = InputHints
InputHintsSpellcheck
    toEnum Int
2 = InputHints
InputHintsNoSpellcheck
    toEnum Int
4 = InputHints
InputHintsWordCompletion
    toEnum Int
8 = InputHints
InputHintsLowercase
    toEnum Int
16 = InputHints
InputHintsUppercaseChars
    toEnum Int
32 = InputHints
InputHintsUppercaseWords
    toEnum Int
64 = InputHints
InputHintsUppercaseSentences
    toEnum Int
128 = InputHints
InputHintsInhibitOsk
    toEnum Int
256 = InputHints
InputHintsVerticalWriting
    toEnum Int
512 = InputHints
InputHintsEmoji
    toEnum Int
1024 = InputHints
InputHintsNoEmoji
    toEnum Int
2048 = InputHints
InputHintsPrivate
    toEnum Int
k = Int -> InputHints
AnotherInputHints Int
k

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

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

foreign import ccall "gtk_input_hints_get_type" c_gtk_input_hints_get_type :: 
    IO GType

instance B.Types.TypedObject InputHints where
    glibType :: IO GType
glibType = IO GType
c_gtk_input_hints_get_type

instance B.Types.BoxedFlags InputHints

instance IsGFlag InputHints

-- Flags IconLookupFlags
-- | Used to specify options for 'GI.Gtk.Objects.IconTheme.iconThemeLookupIcon'.
data IconLookupFlags = 
      IconLookupFlagsForceRegular
    -- ^ Try to always load regular icons, even
    --   when symbolic icon names are given
    | IconLookupFlagsForceSymbolic
    -- ^ Try to always load symbolic icons, even
    --   when regular icon names are given
    | IconLookupFlagsPreload
    -- ^ Starts loading the texture in the background
    --   so it is ready when later needed.
    | AnotherIconLookupFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> IconLookupFlags -> ShowS
[IconLookupFlags] -> ShowS
IconLookupFlags -> String
(Int -> IconLookupFlags -> ShowS)
-> (IconLookupFlags -> String)
-> ([IconLookupFlags] -> ShowS)
-> Show IconLookupFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> IconLookupFlags -> ShowS
showsPrec :: Int -> IconLookupFlags -> ShowS
$cshow :: IconLookupFlags -> String
show :: IconLookupFlags -> String
$cshowList :: [IconLookupFlags] -> ShowS
showList :: [IconLookupFlags] -> ShowS
Show, IconLookupFlags -> IconLookupFlags -> Bool
(IconLookupFlags -> IconLookupFlags -> Bool)
-> (IconLookupFlags -> IconLookupFlags -> Bool)
-> Eq IconLookupFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IconLookupFlags -> IconLookupFlags -> Bool
== :: IconLookupFlags -> IconLookupFlags -> Bool
$c/= :: IconLookupFlags -> IconLookupFlags -> Bool
/= :: IconLookupFlags -> IconLookupFlags -> Bool
Eq)

instance P.Enum IconLookupFlags where
    fromEnum :: IconLookupFlags -> Int
fromEnum IconLookupFlags
IconLookupFlagsForceRegular = Int
1
    fromEnum IconLookupFlags
IconLookupFlagsForceSymbolic = Int
2
    fromEnum IconLookupFlags
IconLookupFlagsPreload = Int
4
    fromEnum (AnotherIconLookupFlags Int
k) = Int
k

    toEnum :: Int -> IconLookupFlags
toEnum Int
1 = IconLookupFlags
IconLookupFlagsForceRegular
    toEnum Int
2 = IconLookupFlags
IconLookupFlagsForceSymbolic
    toEnum Int
4 = IconLookupFlags
IconLookupFlagsPreload
    toEnum Int
k = Int -> IconLookupFlags
AnotherIconLookupFlags Int
k

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

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

foreign import ccall "gtk_icon_lookup_flags_get_type" c_gtk_icon_lookup_flags_get_type :: 
    IO GType

instance B.Types.TypedObject IconLookupFlags where
    glibType :: IO GType
glibType = IO GType
c_gtk_icon_lookup_flags_get_type

instance B.Types.BoxedFlags IconLookupFlags

instance IsGFlag IconLookupFlags

-- Flags FontChooserLevel
-- | Specifies the granularity of font selection
-- that is desired in a @GtkFontChooser@.
-- 
-- This enumeration may be extended in the future; applications should
-- ignore unknown values.
data FontChooserLevel = 
      FontChooserLevelFamily
    -- ^ Allow selecting a font family
    | FontChooserLevelStyle
    -- ^ Allow selecting a specific font face
    | FontChooserLevelSize
    -- ^ Allow selecting a specific font size
    | FontChooserLevelVariations
    -- ^ Allow changing OpenType font variation axes
    | FontChooserLevelFeatures
    -- ^ Allow selecting specific OpenType font features
    | AnotherFontChooserLevel Int
    -- ^ Catch-all for unknown values
    deriving (Int -> FontChooserLevel -> ShowS
[FontChooserLevel] -> ShowS
FontChooserLevel -> String
(Int -> FontChooserLevel -> ShowS)
-> (FontChooserLevel -> String)
-> ([FontChooserLevel] -> ShowS)
-> Show FontChooserLevel
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FontChooserLevel -> ShowS
showsPrec :: Int -> FontChooserLevel -> ShowS
$cshow :: FontChooserLevel -> String
show :: FontChooserLevel -> String
$cshowList :: [FontChooserLevel] -> ShowS
showList :: [FontChooserLevel] -> ShowS
Show, FontChooserLevel -> FontChooserLevel -> Bool
(FontChooserLevel -> FontChooserLevel -> Bool)
-> (FontChooserLevel -> FontChooserLevel -> Bool)
-> Eq FontChooserLevel
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FontChooserLevel -> FontChooserLevel -> Bool
== :: FontChooserLevel -> FontChooserLevel -> Bool
$c/= :: FontChooserLevel -> FontChooserLevel -> Bool
/= :: FontChooserLevel -> FontChooserLevel -> Bool
Eq)

instance P.Enum FontChooserLevel where
    fromEnum :: FontChooserLevel -> Int
fromEnum FontChooserLevel
FontChooserLevelFamily = Int
0
    fromEnum FontChooserLevel
FontChooserLevelStyle = Int
1
    fromEnum FontChooserLevel
FontChooserLevelSize = Int
2
    fromEnum FontChooserLevel
FontChooserLevelVariations = Int
4
    fromEnum FontChooserLevel
FontChooserLevelFeatures = Int
8
    fromEnum (AnotherFontChooserLevel Int
k) = Int
k

    toEnum :: Int -> FontChooserLevel
toEnum Int
0 = FontChooserLevel
FontChooserLevelFamily
    toEnum Int
1 = FontChooserLevel
FontChooserLevelStyle
    toEnum Int
2 = FontChooserLevel
FontChooserLevelSize
    toEnum Int
4 = FontChooserLevel
FontChooserLevelVariations
    toEnum Int
8 = FontChooserLevel
FontChooserLevelFeatures
    toEnum Int
k = Int -> FontChooserLevel
AnotherFontChooserLevel Int
k

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

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

foreign import ccall "gtk_font_chooser_level_get_type" c_gtk_font_chooser_level_get_type :: 
    IO GType

instance B.Types.TypedObject FontChooserLevel where
    glibType :: IO GType
glibType = IO GType
c_gtk_font_chooser_level_get_type

instance B.Types.BoxedFlags FontChooserLevel

instance IsGFlag FontChooserLevel

-- Flags EventControllerScrollFlags
-- | Describes the behavior of a @GtkEventControllerScroll@.
data EventControllerScrollFlags = 
      EventControllerScrollFlagsNone
    -- ^ Don\'t emit scroll.
    | EventControllerScrollFlagsVertical
    -- ^ Emit scroll with vertical deltas.
    | EventControllerScrollFlagsHorizontal
    -- ^ Emit scroll with horizontal deltas.
    | EventControllerScrollFlagsDiscrete
    -- ^ Only emit deltas that are multiples of 1.
    | EventControllerScrollFlagsKinetic
    -- ^ Emit [decelerate](#g:signal:decelerate) after continuous scroll finishes.
    | EventControllerScrollFlagsBothAxes
    -- ^ Emit scroll on both axes.
    | AnotherEventControllerScrollFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> EventControllerScrollFlags -> ShowS
[EventControllerScrollFlags] -> ShowS
EventControllerScrollFlags -> String
(Int -> EventControllerScrollFlags -> ShowS)
-> (EventControllerScrollFlags -> String)
-> ([EventControllerScrollFlags] -> ShowS)
-> Show EventControllerScrollFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> EventControllerScrollFlags -> ShowS
showsPrec :: Int -> EventControllerScrollFlags -> ShowS
$cshow :: EventControllerScrollFlags -> String
show :: EventControllerScrollFlags -> String
$cshowList :: [EventControllerScrollFlags] -> ShowS
showList :: [EventControllerScrollFlags] -> ShowS
Show, EventControllerScrollFlags -> EventControllerScrollFlags -> Bool
(EventControllerScrollFlags -> EventControllerScrollFlags -> Bool)
-> (EventControllerScrollFlags
    -> EventControllerScrollFlags -> Bool)
-> Eq EventControllerScrollFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: EventControllerScrollFlags -> EventControllerScrollFlags -> Bool
== :: EventControllerScrollFlags -> EventControllerScrollFlags -> Bool
$c/= :: EventControllerScrollFlags -> EventControllerScrollFlags -> Bool
/= :: EventControllerScrollFlags -> EventControllerScrollFlags -> Bool
Eq)

instance P.Enum EventControllerScrollFlags where
    fromEnum :: EventControllerScrollFlags -> Int
fromEnum EventControllerScrollFlags
EventControllerScrollFlagsNone = Int
0
    fromEnum EventControllerScrollFlags
EventControllerScrollFlagsVertical = Int
1
    fromEnum EventControllerScrollFlags
EventControllerScrollFlagsHorizontal = Int
2
    fromEnum EventControllerScrollFlags
EventControllerScrollFlagsDiscrete = Int
4
    fromEnum EventControllerScrollFlags
EventControllerScrollFlagsKinetic = Int
8
    fromEnum EventControllerScrollFlags
EventControllerScrollFlagsBothAxes = Int
3
    fromEnum (AnotherEventControllerScrollFlags Int
k) = Int
k

    toEnum :: Int -> EventControllerScrollFlags
toEnum Int
0 = EventControllerScrollFlags
EventControllerScrollFlagsNone
    toEnum Int
1 = EventControllerScrollFlags
EventControllerScrollFlagsVertical
    toEnum Int
2 = EventControllerScrollFlags
EventControllerScrollFlagsHorizontal
    toEnum Int
4 = EventControllerScrollFlags
EventControllerScrollFlagsDiscrete
    toEnum Int
8 = EventControllerScrollFlags
EventControllerScrollFlagsKinetic
    toEnum Int
3 = EventControllerScrollFlags
EventControllerScrollFlagsBothAxes
    toEnum Int
k = Int -> EventControllerScrollFlags
AnotherEventControllerScrollFlags Int
k

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

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

foreign import ccall "gtk_event_controller_scroll_flags_get_type" c_gtk_event_controller_scroll_flags_get_type :: 
    IO GType

instance B.Types.TypedObject EventControllerScrollFlags where
    glibType :: IO GType
glibType = IO GType
c_gtk_event_controller_scroll_flags_get_type

instance B.Types.BoxedFlags EventControllerScrollFlags

instance IsGFlag EventControllerScrollFlags

-- Flags DialogFlags
-- | Flags used to influence dialog construction.
data DialogFlags = 
      DialogFlagsModal
    -- ^ Make the constructed dialog modal
    | DialogFlagsDestroyWithParent
    -- ^ Destroy the dialog when its parent is destroyed
    | DialogFlagsUseHeaderBar
    -- ^ Create dialog with actions in header
    --   bar instead of action area
    | AnotherDialogFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> DialogFlags -> ShowS
[DialogFlags] -> ShowS
DialogFlags -> String
(Int -> DialogFlags -> ShowS)
-> (DialogFlags -> String)
-> ([DialogFlags] -> ShowS)
-> Show DialogFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DialogFlags -> ShowS
showsPrec :: Int -> DialogFlags -> ShowS
$cshow :: DialogFlags -> String
show :: DialogFlags -> String
$cshowList :: [DialogFlags] -> ShowS
showList :: [DialogFlags] -> ShowS
Show, DialogFlags -> DialogFlags -> Bool
(DialogFlags -> DialogFlags -> Bool)
-> (DialogFlags -> DialogFlags -> Bool) -> Eq DialogFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DialogFlags -> DialogFlags -> Bool
== :: DialogFlags -> DialogFlags -> Bool
$c/= :: DialogFlags -> DialogFlags -> Bool
/= :: DialogFlags -> DialogFlags -> Bool
Eq)

instance P.Enum DialogFlags where
    fromEnum :: DialogFlags -> Int
fromEnum DialogFlags
DialogFlagsModal = Int
1
    fromEnum DialogFlags
DialogFlagsDestroyWithParent = Int
2
    fromEnum DialogFlags
DialogFlagsUseHeaderBar = Int
4
    fromEnum (AnotherDialogFlags Int
k) = Int
k

    toEnum :: Int -> DialogFlags
toEnum Int
1 = DialogFlags
DialogFlagsModal
    toEnum Int
2 = DialogFlags
DialogFlagsDestroyWithParent
    toEnum Int
4 = DialogFlags
DialogFlagsUseHeaderBar
    toEnum Int
k = Int -> DialogFlags
AnotherDialogFlags Int
k

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

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

foreign import ccall "gtk_dialog_flags_get_type" c_gtk_dialog_flags_get_type :: 
    IO GType

instance B.Types.TypedObject DialogFlags where
    glibType :: IO GType
glibType = IO GType
c_gtk_dialog_flags_get_type

instance B.Types.BoxedFlags DialogFlags

instance IsGFlag DialogFlags

-- Flags DebugFlags
-- | Flags to use with 'GI.Gtk.Functions.setDebugFlags'.
-- 
-- Settings these flags causes GTK to print out different
-- types of debugging information. Some of these flags are
-- only available when GTK has been configured with @-Ddebug=true@.
data DebugFlags = 
      DebugFlagsText
    -- ^ Information about GtkTextView
    | DebugFlagsTree
    -- ^ Information about GtkTreeView
    | DebugFlagsKeybindings
    -- ^ Information about keyboard shortcuts
    | DebugFlagsModules
    -- ^ Information about modules and extensions
    | DebugFlagsGeometry
    -- ^ Information about size allocation
    | DebugFlagsIcontheme
    -- ^ Information about icon themes
    | DebugFlagsPrinting
    -- ^ Information about printing
    | DebugFlagsBuilder
    -- ^ Trace GtkBuilder operation
    | DebugFlagsSizeRequest
    -- ^ Information about size requests
    | DebugFlagsNoCssCache
    -- ^ Disable the style property cache
    | DebugFlagsInteractive
    -- ^ Open the GTK inspector
    | DebugFlagsTouchscreen
    -- ^ Pretend the pointer is a touchscreen
    | DebugFlagsActions
    -- ^ Information about actions and menu models
    | DebugFlagsLayout
    -- ^ Information from layout managers
    | DebugFlagsSnapshot
    -- ^ Include debug render nodes in the generated snapshots
    | DebugFlagsConstraints
    -- ^ Information from the constraints solver
    | DebugFlagsBuilderObjects
    -- ^ Log unused GtkBuilder objects
    | DebugFlagsA11y
    -- ^ Information about accessibility state changes
    | DebugFlagsIconfallback
    -- ^ Information about icon fallback. Since: 4.2
    | DebugFlagsInvertTextDir
    -- ^ /No description available in the introspection data./
    | AnotherDebugFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> DebugFlags -> ShowS
[DebugFlags] -> ShowS
DebugFlags -> String
(Int -> DebugFlags -> ShowS)
-> (DebugFlags -> String)
-> ([DebugFlags] -> ShowS)
-> Show DebugFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DebugFlags -> ShowS
showsPrec :: Int -> DebugFlags -> ShowS
$cshow :: DebugFlags -> String
show :: DebugFlags -> String
$cshowList :: [DebugFlags] -> ShowS
showList :: [DebugFlags] -> ShowS
Show, DebugFlags -> DebugFlags -> Bool
(DebugFlags -> DebugFlags -> Bool)
-> (DebugFlags -> DebugFlags -> Bool) -> Eq DebugFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DebugFlags -> DebugFlags -> Bool
== :: DebugFlags -> DebugFlags -> Bool
$c/= :: DebugFlags -> DebugFlags -> Bool
/= :: DebugFlags -> DebugFlags -> Bool
Eq)

instance P.Enum DebugFlags where
    fromEnum :: DebugFlags -> Int
fromEnum DebugFlags
DebugFlagsText = Int
1
    fromEnum DebugFlags
DebugFlagsTree = Int
2
    fromEnum DebugFlags
DebugFlagsKeybindings = Int
4
    fromEnum DebugFlags
DebugFlagsModules = Int
8
    fromEnum DebugFlags
DebugFlagsGeometry = Int
16
    fromEnum DebugFlags
DebugFlagsIcontheme = Int
32
    fromEnum DebugFlags
DebugFlagsPrinting = Int
64
    fromEnum DebugFlags
DebugFlagsBuilder = Int
128
    fromEnum DebugFlags
DebugFlagsSizeRequest = Int
256
    fromEnum DebugFlags
DebugFlagsNoCssCache = Int
512
    fromEnum DebugFlags
DebugFlagsInteractive = Int
1024
    fromEnum DebugFlags
DebugFlagsTouchscreen = Int
2048
    fromEnum DebugFlags
DebugFlagsActions = Int
4096
    fromEnum DebugFlags
DebugFlagsLayout = Int
8192
    fromEnum DebugFlags
DebugFlagsSnapshot = Int
16384
    fromEnum DebugFlags
DebugFlagsConstraints = Int
32768
    fromEnum DebugFlags
DebugFlagsBuilderObjects = Int
65536
    fromEnum DebugFlags
DebugFlagsA11y = Int
131072
    fromEnum DebugFlags
DebugFlagsIconfallback = Int
262144
    fromEnum DebugFlags
DebugFlagsInvertTextDir = Int
524288
    fromEnum (AnotherDebugFlags Int
k) = Int
k

    toEnum :: Int -> DebugFlags
toEnum Int
1 = DebugFlags
DebugFlagsText
    toEnum Int
2 = DebugFlags
DebugFlagsTree
    toEnum Int
4 = DebugFlags
DebugFlagsKeybindings
    toEnum Int
8 = DebugFlags
DebugFlagsModules
    toEnum Int
16 = DebugFlags
DebugFlagsGeometry
    toEnum Int
32 = DebugFlags
DebugFlagsIcontheme
    toEnum Int
64 = DebugFlags
DebugFlagsPrinting
    toEnum Int
128 = DebugFlags
DebugFlagsBuilder
    toEnum Int
256 = DebugFlags
DebugFlagsSizeRequest
    toEnum Int
512 = DebugFlags
DebugFlagsNoCssCache
    toEnum Int
1024 = DebugFlags
DebugFlagsInteractive
    toEnum Int
2048 = DebugFlags
DebugFlagsTouchscreen
    toEnum Int
4096 = DebugFlags
DebugFlagsActions
    toEnum Int
8192 = DebugFlags
DebugFlagsLayout
    toEnum Int
16384 = DebugFlags
DebugFlagsSnapshot
    toEnum Int
32768 = DebugFlags
DebugFlagsConstraints
    toEnum Int
65536 = DebugFlags
DebugFlagsBuilderObjects
    toEnum Int
131072 = DebugFlags
DebugFlagsA11y
    toEnum Int
262144 = DebugFlags
DebugFlagsIconfallback
    toEnum Int
524288 = DebugFlags
DebugFlagsInvertTextDir
    toEnum Int
k = Int -> DebugFlags
AnotherDebugFlags Int
k

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

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

foreign import ccall "gtk_debug_flags_get_type" c_gtk_debug_flags_get_type :: 
    IO GType

instance B.Types.TypedObject DebugFlags where
    glibType :: IO GType
glibType = IO GType
c_gtk_debug_flags_get_type

instance B.Types.BoxedFlags DebugFlags

instance IsGFlag DebugFlags

-- Flags CellRendererState
-- | Tells how a cell is to be rendered.
data CellRendererState = 
      CellRendererStateSelected
    -- ^ The cell is currently selected, and
    --  probably has a selection colored background to render to.
    | CellRendererStatePrelit
    -- ^ The mouse is hovering over the cell.
    | CellRendererStateInsensitive
    -- ^ The cell is drawn in an insensitive manner
    | CellRendererStateSorted
    -- ^ The cell is in a sorted row
    | CellRendererStateFocused
    -- ^ The cell is in the focus row.
    | CellRendererStateExpandable
    -- ^ The cell is in a row that can be expanded
    | CellRendererStateExpanded
    -- ^ The cell is in a row that is expanded
    | AnotherCellRendererState Int
    -- ^ Catch-all for unknown values
    deriving (Int -> CellRendererState -> ShowS
[CellRendererState] -> ShowS
CellRendererState -> String
(Int -> CellRendererState -> ShowS)
-> (CellRendererState -> String)
-> ([CellRendererState] -> ShowS)
-> Show CellRendererState
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CellRendererState -> ShowS
showsPrec :: Int -> CellRendererState -> ShowS
$cshow :: CellRendererState -> String
show :: CellRendererState -> String
$cshowList :: [CellRendererState] -> ShowS
showList :: [CellRendererState] -> ShowS
Show, CellRendererState -> CellRendererState -> Bool
(CellRendererState -> CellRendererState -> Bool)
-> (CellRendererState -> CellRendererState -> Bool)
-> Eq CellRendererState
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CellRendererState -> CellRendererState -> Bool
== :: CellRendererState -> CellRendererState -> Bool
$c/= :: CellRendererState -> CellRendererState -> Bool
/= :: CellRendererState -> CellRendererState -> Bool
Eq)

instance P.Enum CellRendererState where
    fromEnum :: CellRendererState -> Int
fromEnum CellRendererState
CellRendererStateSelected = Int
1
    fromEnum CellRendererState
CellRendererStatePrelit = Int
2
    fromEnum CellRendererState
CellRendererStateInsensitive = Int
4
    fromEnum CellRendererState
CellRendererStateSorted = Int
8
    fromEnum CellRendererState
CellRendererStateFocused = Int
16
    fromEnum CellRendererState
CellRendererStateExpandable = Int
32
    fromEnum CellRendererState
CellRendererStateExpanded = Int
64
    fromEnum (AnotherCellRendererState Int
k) = Int
k

    toEnum :: Int -> CellRendererState
toEnum Int
1 = CellRendererState
CellRendererStateSelected
    toEnum Int
2 = CellRendererState
CellRendererStatePrelit
    toEnum Int
4 = CellRendererState
CellRendererStateInsensitive
    toEnum Int
8 = CellRendererState
CellRendererStateSorted
    toEnum Int
16 = CellRendererState
CellRendererStateFocused
    toEnum Int
32 = CellRendererState
CellRendererStateExpandable
    toEnum Int
64 = CellRendererState
CellRendererStateExpanded
    toEnum Int
k = Int -> CellRendererState
AnotherCellRendererState Int
k

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

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

foreign import ccall "gtk_cell_renderer_state_get_type" c_gtk_cell_renderer_state_get_type :: 
    IO GType

instance B.Types.TypedObject CellRendererState where
    glibType :: IO GType
glibType = IO GType
c_gtk_cell_renderer_state_get_type

instance B.Types.BoxedFlags CellRendererState

instance IsGFlag CellRendererState

-- Flags BuilderClosureFlags
-- | The list of flags that can be passed to 'GI.Gtk.Objects.Builder.builderCreateClosure'.
-- 
-- New values may be added in the future for new features, so external
-- implementations of t'GI.Gtk.Interfaces.BuilderScope.BuilderScope' should test the flags
-- for unknown values and raise a 'GI.Gtk.Enums.BuilderErrorInvalidAttribute' error
-- when they encounter one.
data BuilderClosureFlags = 
      BuilderClosureFlagsSwapped
    -- ^ The closure should be created swapped. See
    --   @/g_cclosure_new_swap()/@ for details.
    | AnotherBuilderClosureFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> BuilderClosureFlags -> ShowS
[BuilderClosureFlags] -> ShowS
BuilderClosureFlags -> String
(Int -> BuilderClosureFlags -> ShowS)
-> (BuilderClosureFlags -> String)
-> ([BuilderClosureFlags] -> ShowS)
-> Show BuilderClosureFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BuilderClosureFlags -> ShowS
showsPrec :: Int -> BuilderClosureFlags -> ShowS
$cshow :: BuilderClosureFlags -> String
show :: BuilderClosureFlags -> String
$cshowList :: [BuilderClosureFlags] -> ShowS
showList :: [BuilderClosureFlags] -> ShowS
Show, BuilderClosureFlags -> BuilderClosureFlags -> Bool
(BuilderClosureFlags -> BuilderClosureFlags -> Bool)
-> (BuilderClosureFlags -> BuilderClosureFlags -> Bool)
-> Eq BuilderClosureFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BuilderClosureFlags -> BuilderClosureFlags -> Bool
== :: BuilderClosureFlags -> BuilderClosureFlags -> Bool
$c/= :: BuilderClosureFlags -> BuilderClosureFlags -> Bool
/= :: BuilderClosureFlags -> BuilderClosureFlags -> Bool
Eq)

instance P.Enum BuilderClosureFlags where
    fromEnum :: BuilderClosureFlags -> Int
fromEnum BuilderClosureFlags
BuilderClosureFlagsSwapped = Int
1
    fromEnum (AnotherBuilderClosureFlags Int
k) = Int
k

    toEnum :: Int -> BuilderClosureFlags
toEnum Int
1 = BuilderClosureFlags
BuilderClosureFlagsSwapped
    toEnum Int
k = Int -> BuilderClosureFlags
AnotherBuilderClosureFlags Int
k

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

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

foreign import ccall "gtk_builder_closure_flags_get_type" c_gtk_builder_closure_flags_get_type :: 
    IO GType

instance B.Types.TypedObject BuilderClosureFlags where
    glibType :: IO GType
glibType = IO GType
c_gtk_builder_closure_flags_get_type

instance B.Types.BoxedFlags BuilderClosureFlags

instance IsGFlag BuilderClosureFlags

-- Flags ApplicationInhibitFlags
-- | Types of user actions that may be blocked by @GtkApplication@.
-- 
-- See 'GI.Gtk.Objects.Application.applicationInhibit'.
data ApplicationInhibitFlags = 
      ApplicationInhibitFlagsLogout
    -- ^ Inhibit ending the user session
    --   by logging out or by shutting down the computer
    | ApplicationInhibitFlagsSwitch
    -- ^ Inhibit user switching
    | ApplicationInhibitFlagsSuspend
    -- ^ Inhibit suspending the
    --   session or computer
    | ApplicationInhibitFlagsIdle
    -- ^ Inhibit the session being
    --   marked as idle (and possibly locked)
    | AnotherApplicationInhibitFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ApplicationInhibitFlags -> ShowS
[ApplicationInhibitFlags] -> ShowS
ApplicationInhibitFlags -> String
(Int -> ApplicationInhibitFlags -> ShowS)
-> (ApplicationInhibitFlags -> String)
-> ([ApplicationInhibitFlags] -> ShowS)
-> Show ApplicationInhibitFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ApplicationInhibitFlags -> ShowS
showsPrec :: Int -> ApplicationInhibitFlags -> ShowS
$cshow :: ApplicationInhibitFlags -> String
show :: ApplicationInhibitFlags -> String
$cshowList :: [ApplicationInhibitFlags] -> ShowS
showList :: [ApplicationInhibitFlags] -> ShowS
Show, ApplicationInhibitFlags -> ApplicationInhibitFlags -> Bool
(ApplicationInhibitFlags -> ApplicationInhibitFlags -> Bool)
-> (ApplicationInhibitFlags -> ApplicationInhibitFlags -> Bool)
-> Eq ApplicationInhibitFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ApplicationInhibitFlags -> ApplicationInhibitFlags -> Bool
== :: ApplicationInhibitFlags -> ApplicationInhibitFlags -> Bool
$c/= :: ApplicationInhibitFlags -> ApplicationInhibitFlags -> Bool
/= :: ApplicationInhibitFlags -> ApplicationInhibitFlags -> Bool
Eq)

instance P.Enum ApplicationInhibitFlags where
    fromEnum :: ApplicationInhibitFlags -> Int
fromEnum ApplicationInhibitFlags
ApplicationInhibitFlagsLogout = Int
1
    fromEnum ApplicationInhibitFlags
ApplicationInhibitFlagsSwitch = Int
2
    fromEnum ApplicationInhibitFlags
ApplicationInhibitFlagsSuspend = Int
4
    fromEnum ApplicationInhibitFlags
ApplicationInhibitFlagsIdle = Int
8
    fromEnum (AnotherApplicationInhibitFlags Int
k) = Int
k

    toEnum :: Int -> ApplicationInhibitFlags
toEnum Int
1 = ApplicationInhibitFlags
ApplicationInhibitFlagsLogout
    toEnum Int
2 = ApplicationInhibitFlags
ApplicationInhibitFlagsSwitch
    toEnum Int
4 = ApplicationInhibitFlags
ApplicationInhibitFlagsSuspend
    toEnum Int
8 = ApplicationInhibitFlags
ApplicationInhibitFlagsIdle
    toEnum Int
k = Int -> ApplicationInhibitFlags
AnotherApplicationInhibitFlags Int
k

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

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

foreign import ccall "gtk_application_inhibit_flags_get_type" c_gtk_application_inhibit_flags_get_type :: 
    IO GType

instance B.Types.TypedObject ApplicationInhibitFlags where
    glibType :: IO GType
glibType = IO GType
c_gtk_application_inhibit_flags_get_type

instance B.Types.BoxedFlags ApplicationInhibitFlags

instance IsGFlag ApplicationInhibitFlags