-- | 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.Gtk.Flags
    ( 

 -- * Flags
-- ** AccelFlags #flag:AccelFlags#

    AccelFlags(..)                          ,


-- ** ApplicationInhibitFlags #flag:ApplicationInhibitFlags#

    ApplicationInhibitFlags(..)             ,


-- ** CalendarDisplayOptions #flag:CalendarDisplayOptions#

    CalendarDisplayOptions(..)              ,


-- ** CellRendererState #flag:CellRendererState#

    CellRendererState(..)                   ,


-- ** DebugFlag #flag:DebugFlag#

    DebugFlag(..)                           ,


-- ** DestDefaults #flag:DestDefaults#

    DestDefaults(..)                        ,


-- ** DialogFlags #flag:DialogFlags#

    DialogFlags(..)                         ,


-- ** EventControllerScrollFlags #flag:EventControllerScrollFlags#

    EventControllerScrollFlags(..)          ,


-- ** FileFilterFlags #flag:FileFilterFlags#

    FileFilterFlags(..)                     ,


-- ** FontChooserLevel #flag:FontChooserLevel#

    FontChooserLevel(..)                    ,


-- ** IconLookupFlags #flag:IconLookupFlags#

    IconLookupFlags(..)                     ,


-- ** InputHints #flag:InputHints#

    InputHints(..)                          ,


-- ** PickFlags #flag:PickFlags#

    PickFlags(..)                           ,


-- ** PlacesOpenFlags #flag:PlacesOpenFlags#

    PlacesOpenFlags(..)                     ,


-- ** 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.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 TreeModelFlags
-- | These flags indicate various properties of a t'GI.Gtk.Interfaces.TreeModel.TreeModel'.
-- 
-- They are returned by 'GI.Gtk.Interfaces.TreeModel.treeModelGetFlags', and must be
-- static for the lifetime of the object. A more complete description
-- of @/GTK_TREE_MODEL_ITERS_PERSIST/@ 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
showList :: [TreeModelFlags] -> ShowS
$cshowList :: [TreeModelFlags] -> ShowS
show :: TreeModelFlags -> String
$cshow :: TreeModelFlags -> String
showsPrec :: Int -> TreeModelFlags -> ShowS
$cshowsPrec :: Int -> TreeModelFlags -> ShowS
Show, TreeModelFlags -> TreeModelFlags -> Bool
(TreeModelFlags -> TreeModelFlags -> Bool)
-> (TreeModelFlags -> TreeModelFlags -> Bool) -> Eq TreeModelFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TreeModelFlags -> TreeModelFlags -> Bool
$c/= :: TreeModelFlags -> TreeModelFlags -> Bool
== :: TreeModelFlags -> TreeModelFlags -> Bool
$c== :: TreeModelFlags -> TreeModelFlags -> Bool
Eq)

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

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

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

foreign import ccall "gtk_tree_model_flags_get_type" c_gtk_tree_model_flags_get_type :: 
    IO GType

instance BoxedFlags TreeModelFlags where
    boxedFlagsType :: Proxy TreeModelFlags -> IO GType
boxedFlagsType _ = IO GType
c_gtk_tree_model_flags_get_type

instance IsGFlag TreeModelFlags

-- Flags TextSearchFlags
-- | Flags affecting how a search is done.
-- 
-- If neither @/GTK_TEXT_SEARCH_VISIBLE_ONLY/@ nor @/GTK_TEXT_SEARCH_TEXT_ONLY/@ are
-- enabled, the match must be exact; the special 0xFFFC character will match
-- embedded textures 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 textures 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
showList :: [TextSearchFlags] -> ShowS
$cshowList :: [TextSearchFlags] -> ShowS
show :: TextSearchFlags -> String
$cshow :: TextSearchFlags -> String
showsPrec :: Int -> TextSearchFlags -> ShowS
$cshowsPrec :: Int -> TextSearchFlags -> ShowS
Show, TextSearchFlags -> TextSearchFlags -> Bool
(TextSearchFlags -> TextSearchFlags -> Bool)
-> (TextSearchFlags -> TextSearchFlags -> Bool)
-> Eq TextSearchFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TextSearchFlags -> TextSearchFlags -> Bool
$c/= :: TextSearchFlags -> TextSearchFlags -> Bool
== :: TextSearchFlags -> TextSearchFlags -> Bool
$c== :: TextSearchFlags -> TextSearchFlags -> Bool
Eq)

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

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

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

foreign import ccall "gtk_text_search_flags_get_type" c_gtk_text_search_flags_get_type :: 
    IO GType

instance BoxedFlags TextSearchFlags where
    boxedFlagsType :: Proxy TextSearchFlags -> IO GType
boxedFlagsType _ = IO GType
c_gtk_text_search_flags_get_type

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
    | 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
showList :: [StyleContextPrintFlags] -> ShowS
$cshowList :: [StyleContextPrintFlags] -> ShowS
show :: StyleContextPrintFlags -> String
$cshow :: StyleContextPrintFlags -> String
showsPrec :: Int -> StyleContextPrintFlags -> ShowS
$cshowsPrec :: Int -> StyleContextPrintFlags -> ShowS
Show, StyleContextPrintFlags -> StyleContextPrintFlags -> Bool
(StyleContextPrintFlags -> StyleContextPrintFlags -> Bool)
-> (StyleContextPrintFlags -> StyleContextPrintFlags -> Bool)
-> Eq StyleContextPrintFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StyleContextPrintFlags -> StyleContextPrintFlags -> Bool
$c/= :: StyleContextPrintFlags -> StyleContextPrintFlags -> Bool
== :: StyleContextPrintFlags -> StyleContextPrintFlags -> Bool
$c== :: StyleContextPrintFlags -> StyleContextPrintFlags -> Bool
Eq)

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

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

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

foreign import ccall "gtk_style_context_print_flags_get_type" c_gtk_style_context_print_flags_get_type :: 
    IO GType

instance BoxedFlags StyleContextPrintFlags where
    boxedFlagsType :: Proxy StyleContextPrintFlags -> IO GType
boxedFlagsType _ = IO GType
c_gtk_style_context_print_flags_get_type

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
    | 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
showList :: [StateFlags] -> ShowS
$cshowList :: [StateFlags] -> ShowS
show :: StateFlags -> String
$cshow :: StateFlags -> String
showsPrec :: Int -> StateFlags -> ShowS
$cshowsPrec :: Int -> StateFlags -> ShowS
Show, StateFlags -> StateFlags -> Bool
(StateFlags -> StateFlags -> Bool)
-> (StateFlags -> StateFlags -> Bool) -> Eq StateFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StateFlags -> StateFlags -> Bool
$c/= :: StateFlags -> StateFlags -> Bool
== :: StateFlags -> StateFlags -> Bool
$c== :: StateFlags -> StateFlags -> Bool
Eq)

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

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

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

foreign import ccall "gtk_state_flags_get_type" c_gtk_state_flags_get_type :: 
    IO GType

instance BoxedFlags StateFlags where
    boxedFlagsType :: Proxy StateFlags -> IO GType
boxedFlagsType _ = IO GType
c_gtk_state_flags_get_type

instance IsGFlag StateFlags

-- Flags PlacesOpenFlags
-- | /No description available in the introspection data./
data PlacesOpenFlags = 
      PlacesOpenFlagsNormal
    -- ^ /No description available in the introspection data./
    | PlacesOpenFlagsNewTab
    -- ^ /No description available in the introspection data./
    | PlacesOpenFlagsNewWindow
    -- ^ /No description available in the introspection data./
    | AnotherPlacesOpenFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PlacesOpenFlags -> ShowS
[PlacesOpenFlags] -> ShowS
PlacesOpenFlags -> String
(Int -> PlacesOpenFlags -> ShowS)
-> (PlacesOpenFlags -> String)
-> ([PlacesOpenFlags] -> ShowS)
-> Show PlacesOpenFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PlacesOpenFlags] -> ShowS
$cshowList :: [PlacesOpenFlags] -> ShowS
show :: PlacesOpenFlags -> String
$cshow :: PlacesOpenFlags -> String
showsPrec :: Int -> PlacesOpenFlags -> ShowS
$cshowsPrec :: Int -> PlacesOpenFlags -> ShowS
Show, PlacesOpenFlags -> PlacesOpenFlags -> Bool
(PlacesOpenFlags -> PlacesOpenFlags -> Bool)
-> (PlacesOpenFlags -> PlacesOpenFlags -> Bool)
-> Eq PlacesOpenFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PlacesOpenFlags -> PlacesOpenFlags -> Bool
$c/= :: PlacesOpenFlags -> PlacesOpenFlags -> Bool
== :: PlacesOpenFlags -> PlacesOpenFlags -> Bool
$c== :: PlacesOpenFlags -> PlacesOpenFlags -> Bool
Eq)

instance P.Enum PlacesOpenFlags where
    fromEnum :: PlacesOpenFlags -> Int
fromEnum PlacesOpenFlagsNormal = 1
    fromEnum PlacesOpenFlagsNewTab = 2
    fromEnum PlacesOpenFlagsNewWindow = 4
    fromEnum (AnotherPlacesOpenFlags k :: Int
k) = Int
k

    toEnum :: Int -> PlacesOpenFlags
toEnum 1 = PlacesOpenFlags
PlacesOpenFlagsNormal
    toEnum 2 = PlacesOpenFlags
PlacesOpenFlagsNewTab
    toEnum 4 = PlacesOpenFlags
PlacesOpenFlagsNewWindow
    toEnum k :: Int
k = Int -> PlacesOpenFlags
AnotherPlacesOpenFlags Int
k

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

foreign import ccall "gtk_places_open_flags_get_type" c_gtk_places_open_flags_get_type :: 
    IO GType

instance BoxedFlags PlacesOpenFlags where
    boxedFlagsType :: Proxy PlacesOpenFlags -> IO GType
boxedFlagsType _ = IO GType
c_gtk_places_open_flags_get_type

instance IsGFlag PlacesOpenFlags

-- Flags PickFlags
-- | Flags that influence the behavior of 'GI.Gtk.Objects.Widget.widgetPick'
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 t'GI.Gtk.Objects.Widget.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
showList :: [PickFlags] -> ShowS
$cshowList :: [PickFlags] -> ShowS
show :: PickFlags -> String
$cshow :: PickFlags -> String
showsPrec :: Int -> PickFlags -> ShowS
$cshowsPrec :: Int -> PickFlags -> ShowS
Show, PickFlags -> PickFlags -> Bool
(PickFlags -> PickFlags -> Bool)
-> (PickFlags -> PickFlags -> Bool) -> Eq PickFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PickFlags -> PickFlags -> Bool
$c/= :: PickFlags -> PickFlags -> Bool
== :: PickFlags -> PickFlags -> Bool
$c== :: PickFlags -> PickFlags -> Bool
Eq)

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

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

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

foreign import ccall "gtk_pick_flags_get_type" c_gtk_pick_flags_get_type :: 
    IO GType

instance BoxedFlags PickFlags where
    boxedFlagsType :: Proxy PickFlags -> IO GType
boxedFlagsType _ = IO GType
c_gtk_pick_flags_get_type

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 t'GI.Gtk.Enums.InputPurpose' of the entry.
-- 
-- Some common sense is expected when using these flags - mixing
-- /@gTKINPUTHINTLOWERCASE@/ 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
    | 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
showList :: [InputHints] -> ShowS
$cshowList :: [InputHints] -> ShowS
show :: InputHints -> String
$cshow :: InputHints -> String
showsPrec :: Int -> InputHints -> ShowS
$cshowsPrec :: Int -> InputHints -> ShowS
Show, InputHints -> InputHints -> Bool
(InputHints -> InputHints -> Bool)
-> (InputHints -> InputHints -> Bool) -> Eq InputHints
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: InputHints -> InputHints -> Bool
$c/= :: InputHints -> InputHints -> Bool
== :: InputHints -> InputHints -> Bool
$c== :: InputHints -> InputHints -> Bool
Eq)

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

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

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

foreign import ccall "gtk_input_hints_get_type" c_gtk_input_hints_get_type :: 
    IO GType

instance BoxedFlags InputHints where
    boxedFlagsType :: Proxy InputHints -> IO GType
boxedFlagsType _ = IO GType
c_gtk_input_hints_get_type

instance IsGFlag InputHints

-- Flags IconLookupFlags
-- | Used to specify options for 'GI.Gtk.Objects.IconTheme.iconThemeLookupIcon'
data IconLookupFlags = 
      IconLookupFlagsNoSvg
    -- ^ Never get SVG icons, even if gdk-pixbuf
    --   supports them. Cannot be used together with 'GI.Gtk.Flags.IconLookupFlagsForceSvg'.
    | IconLookupFlagsForceSvg
    -- ^ Get SVG icons, even if gdk-pixbuf
    --   doesn’t support them.
    --   Cannot be used together with 'GI.Gtk.Flags.IconLookupFlagsNoSvg'.
    | IconLookupFlagsUseBuiltin
    -- ^ When passed to
    --   'GI.Gtk.Objects.IconTheme.iconThemeLookupIcon' includes builtin icons
    --   as well as files. For a builtin icon, 'GI.Gtk.Objects.IconInfo.iconInfoGetFilename'
    --   is 'P.Nothing' and you need to call @/gtk_icon_info_get_builtin_pixbuf()/@.
    | IconLookupFlagsGenericFallback
    -- ^ Try to shorten icon name at \'-\'
    --   characters before looking at inherited themes. This flag is only
    --   supported in functions that take a single icon name. For more general
    --   fallback, see 'GI.Gtk.Objects.IconTheme.iconThemeChooseIcon'
    | IconLookupFlagsForceSize
    -- ^ Always get the icon scaled to the
    --   requested size
    | 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
    | IconLookupFlagsDirLtr
    -- ^ Try to load a variant of the icon for left-to-right
    --   text direction
    | IconLookupFlagsDirRtl
    -- ^ Try to load a variant of the icon for right-to-left
    --   text direction
    | 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
showList :: [IconLookupFlags] -> ShowS
$cshowList :: [IconLookupFlags] -> ShowS
show :: IconLookupFlags -> String
$cshow :: IconLookupFlags -> String
showsPrec :: Int -> IconLookupFlags -> ShowS
$cshowsPrec :: Int -> IconLookupFlags -> ShowS
Show, IconLookupFlags -> IconLookupFlags -> Bool
(IconLookupFlags -> IconLookupFlags -> Bool)
-> (IconLookupFlags -> IconLookupFlags -> Bool)
-> Eq IconLookupFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: IconLookupFlags -> IconLookupFlags -> Bool
$c/= :: IconLookupFlags -> IconLookupFlags -> Bool
== :: IconLookupFlags -> IconLookupFlags -> Bool
$c== :: IconLookupFlags -> IconLookupFlags -> Bool
Eq)

instance P.Enum IconLookupFlags where
    fromEnum :: IconLookupFlags -> Int
fromEnum IconLookupFlagsNoSvg = 1
    fromEnum IconLookupFlagsForceSvg = 2
    fromEnum IconLookupFlagsUseBuiltin = 4
    fromEnum IconLookupFlagsGenericFallback = 8
    fromEnum IconLookupFlagsForceSize = 16
    fromEnum IconLookupFlagsForceRegular = 32
    fromEnum IconLookupFlagsForceSymbolic = 64
    fromEnum IconLookupFlagsDirLtr = 128
    fromEnum IconLookupFlagsDirRtl = 256
    fromEnum (AnotherIconLookupFlags k :: Int
k) = Int
k

    toEnum :: Int -> IconLookupFlags
toEnum 1 = IconLookupFlags
IconLookupFlagsNoSvg
    toEnum 2 = IconLookupFlags
IconLookupFlagsForceSvg
    toEnum 4 = IconLookupFlags
IconLookupFlagsUseBuiltin
    toEnum 8 = IconLookupFlags
IconLookupFlagsGenericFallback
    toEnum 16 = IconLookupFlags
IconLookupFlagsForceSize
    toEnum 32 = IconLookupFlags
IconLookupFlagsForceRegular
    toEnum 64 = IconLookupFlags
IconLookupFlagsForceSymbolic
    toEnum 128 = IconLookupFlags
IconLookupFlagsDirLtr
    toEnum 256 = IconLookupFlags
IconLookupFlagsDirRtl
    toEnum k :: Int
k = Int -> IconLookupFlags
AnotherIconLookupFlags Int
k

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

foreign import ccall "gtk_icon_lookup_flags_get_type" c_gtk_icon_lookup_flags_get_type :: 
    IO GType

instance BoxedFlags IconLookupFlags where
    boxedFlagsType :: Proxy IconLookupFlags -> IO GType
boxedFlagsType _ = IO GType
c_gtk_icon_lookup_flags_get_type

instance IsGFlag IconLookupFlags

-- Flags FontChooserLevel
-- | This enumeration specifies the granularity of font selection
-- that is desired in a font chooser.
-- 
-- 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
showList :: [FontChooserLevel] -> ShowS
$cshowList :: [FontChooserLevel] -> ShowS
show :: FontChooserLevel -> String
$cshow :: FontChooserLevel -> String
showsPrec :: Int -> FontChooserLevel -> ShowS
$cshowsPrec :: Int -> FontChooserLevel -> ShowS
Show, FontChooserLevel -> FontChooserLevel -> Bool
(FontChooserLevel -> FontChooserLevel -> Bool)
-> (FontChooserLevel -> FontChooserLevel -> Bool)
-> Eq FontChooserLevel
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FontChooserLevel -> FontChooserLevel -> Bool
$c/= :: FontChooserLevel -> FontChooserLevel -> Bool
== :: FontChooserLevel -> FontChooserLevel -> Bool
$c== :: FontChooserLevel -> FontChooserLevel -> Bool
Eq)

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

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

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

foreign import ccall "gtk_font_chooser_level_get_type" c_gtk_font_chooser_level_get_type :: 
    IO GType

instance BoxedFlags FontChooserLevel where
    boxedFlagsType :: Proxy FontChooserLevel -> IO GType
boxedFlagsType _ = IO GType
c_gtk_font_chooser_level_get_type

instance IsGFlag FontChooserLevel

-- Flags FileFilterFlags
-- | These flags indicate what parts of a t'GI.Gtk.Structs.FileFilterInfo.FileFilterInfo' struct
-- are filled or need to be filled.
data FileFilterFlags = 
      FileFilterFlagsFilename
    -- ^ the filename of the file being tested
    | FileFilterFlagsUri
    -- ^ the URI for the file being tested
    | FileFilterFlagsDisplayName
    -- ^ the string that will be used to
    --   display the file in the file chooser
    | FileFilterFlagsMimeType
    -- ^ the mime type of the file
    | AnotherFileFilterFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> FileFilterFlags -> ShowS
[FileFilterFlags] -> ShowS
FileFilterFlags -> String
(Int -> FileFilterFlags -> ShowS)
-> (FileFilterFlags -> String)
-> ([FileFilterFlags] -> ShowS)
-> Show FileFilterFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FileFilterFlags] -> ShowS
$cshowList :: [FileFilterFlags] -> ShowS
show :: FileFilterFlags -> String
$cshow :: FileFilterFlags -> String
showsPrec :: Int -> FileFilterFlags -> ShowS
$cshowsPrec :: Int -> FileFilterFlags -> ShowS
Show, FileFilterFlags -> FileFilterFlags -> Bool
(FileFilterFlags -> FileFilterFlags -> Bool)
-> (FileFilterFlags -> FileFilterFlags -> Bool)
-> Eq FileFilterFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FileFilterFlags -> FileFilterFlags -> Bool
$c/= :: FileFilterFlags -> FileFilterFlags -> Bool
== :: FileFilterFlags -> FileFilterFlags -> Bool
$c== :: FileFilterFlags -> FileFilterFlags -> Bool
Eq)

instance P.Enum FileFilterFlags where
    fromEnum :: FileFilterFlags -> Int
fromEnum FileFilterFlagsFilename = 1
    fromEnum FileFilterFlagsUri = 2
    fromEnum FileFilterFlagsDisplayName = 4
    fromEnum FileFilterFlagsMimeType = 8
    fromEnum (AnotherFileFilterFlags k :: Int
k) = Int
k

    toEnum :: Int -> FileFilterFlags
toEnum 1 = FileFilterFlags
FileFilterFlagsFilename
    toEnum 2 = FileFilterFlags
FileFilterFlagsUri
    toEnum 4 = FileFilterFlags
FileFilterFlagsDisplayName
    toEnum 8 = FileFilterFlags
FileFilterFlagsMimeType
    toEnum k :: Int
k = Int -> FileFilterFlags
AnotherFileFilterFlags Int
k

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

foreign import ccall "gtk_file_filter_flags_get_type" c_gtk_file_filter_flags_get_type :: 
    IO GType

instance BoxedFlags FileFilterFlags where
    boxedFlagsType :: Proxy FileFilterFlags -> IO GType
boxedFlagsType _ = IO GType
c_gtk_file_filter_flags_get_type

instance IsGFlag FileFilterFlags

-- Flags EventControllerScrollFlags
-- | Describes the behavior of a t'GI.Gtk.Objects.EventControllerScroll.EventControllerScroll'.
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]("GI.Gtk.Objects.EventControllerScroll#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
showList :: [EventControllerScrollFlags] -> ShowS
$cshowList :: [EventControllerScrollFlags] -> ShowS
show :: EventControllerScrollFlags -> String
$cshow :: EventControllerScrollFlags -> String
showsPrec :: Int -> EventControllerScrollFlags -> ShowS
$cshowsPrec :: Int -> EventControllerScrollFlags -> ShowS
Show, EventControllerScrollFlags -> EventControllerScrollFlags -> Bool
(EventControllerScrollFlags -> EventControllerScrollFlags -> Bool)
-> (EventControllerScrollFlags
    -> EventControllerScrollFlags -> Bool)
-> Eq EventControllerScrollFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: EventControllerScrollFlags -> EventControllerScrollFlags -> Bool
$c/= :: EventControllerScrollFlags -> EventControllerScrollFlags -> Bool
== :: EventControllerScrollFlags -> EventControllerScrollFlags -> Bool
$c== :: EventControllerScrollFlags -> EventControllerScrollFlags -> Bool
Eq)

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

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

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

foreign import ccall "gtk_event_controller_scroll_flags_get_type" c_gtk_event_controller_scroll_flags_get_type :: 
    IO GType

instance BoxedFlags EventControllerScrollFlags where
    boxedFlagsType :: Proxy EventControllerScrollFlags -> IO GType
boxedFlagsType _ = IO GType
c_gtk_event_controller_scroll_flags_get_type

instance IsGFlag EventControllerScrollFlags

-- Flags DialogFlags
-- | Flags used to influence dialog construction.
data DialogFlags = 
      DialogFlagsModal
    -- ^ Make the constructed dialog modal,
    --     see 'GI.Gtk.Objects.Window.windowSetModal'
    | DialogFlagsDestroyWithParent
    -- ^ Destroy the dialog when its
    --     parent is destroyed, see 'GI.Gtk.Objects.Window.windowSetDestroyWithParent'
    | 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
showList :: [DialogFlags] -> ShowS
$cshowList :: [DialogFlags] -> ShowS
show :: DialogFlags -> String
$cshow :: DialogFlags -> String
showsPrec :: Int -> DialogFlags -> ShowS
$cshowsPrec :: Int -> DialogFlags -> ShowS
Show, DialogFlags -> DialogFlags -> Bool
(DialogFlags -> DialogFlags -> Bool)
-> (DialogFlags -> DialogFlags -> Bool) -> Eq DialogFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DialogFlags -> DialogFlags -> Bool
$c/= :: DialogFlags -> DialogFlags -> Bool
== :: DialogFlags -> DialogFlags -> Bool
$c== :: DialogFlags -> DialogFlags -> Bool
Eq)

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

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

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

foreign import ccall "gtk_dialog_flags_get_type" c_gtk_dialog_flags_get_type :: 
    IO GType

instance BoxedFlags DialogFlags where
    boxedFlagsType :: Proxy DialogFlags -> IO GType
boxedFlagsType _ = IO GType
c_gtk_dialog_flags_get_type

instance IsGFlag DialogFlags

-- Flags DestDefaults
-- | The t'GI.Gtk.Flags.DestDefaults' enumeration specifies the various
-- types of action that will be taken on behalf
-- of the user for a drag destination site.
data DestDefaults = 
      DestDefaultsMotion
    -- ^ If set for a widget, GTK+, during a drag over this
    --   widget will check if the drag matches this widget’s list of possible formats
    --   and actions.
    --   GTK+ will then call @/gdk_drag_status()/@ as appropriate.
    | DestDefaultsHighlight
    -- ^ If set for a widget, GTK+ will draw a highlight on
    --   this widget as long as a drag is over this widget and the widget drag format
    --   and action are acceptable.
    | DestDefaultsDrop
    -- ^ If set for a widget, when a drop occurs, GTK+ will
    --   will check if the drag matches this widget’s list of possible formats and
    --   actions. If so, GTK+ will call 'GI.Gtk.Objects.Widget.widgetDragGetData' on behalf of the widget.
    --   Whether or not the drop is successful, GTK+ will call @/gdk_drag_finish()/@. If
    --   the action was a move, then if the drag was successful, then 'P.True' will be
    --   passed for the /@delete@/ parameter to @/gdk_drag_finish()/@.
    | DestDefaultsAll
    -- ^ If set, specifies that all default actions should
    --   be taken.
    | AnotherDestDefaults Int
    -- ^ Catch-all for unknown values
    deriving (Int -> DestDefaults -> ShowS
[DestDefaults] -> ShowS
DestDefaults -> String
(Int -> DestDefaults -> ShowS)
-> (DestDefaults -> String)
-> ([DestDefaults] -> ShowS)
-> Show DestDefaults
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DestDefaults] -> ShowS
$cshowList :: [DestDefaults] -> ShowS
show :: DestDefaults -> String
$cshow :: DestDefaults -> String
showsPrec :: Int -> DestDefaults -> ShowS
$cshowsPrec :: Int -> DestDefaults -> ShowS
Show, DestDefaults -> DestDefaults -> Bool
(DestDefaults -> DestDefaults -> Bool)
-> (DestDefaults -> DestDefaults -> Bool) -> Eq DestDefaults
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DestDefaults -> DestDefaults -> Bool
$c/= :: DestDefaults -> DestDefaults -> Bool
== :: DestDefaults -> DestDefaults -> Bool
$c== :: DestDefaults -> DestDefaults -> Bool
Eq)

instance P.Enum DestDefaults where
    fromEnum :: DestDefaults -> Int
fromEnum DestDefaultsMotion = 1
    fromEnum DestDefaultsHighlight = 2
    fromEnum DestDefaultsDrop = 4
    fromEnum DestDefaultsAll = 7
    fromEnum (AnotherDestDefaults k :: Int
k) = Int
k

    toEnum :: Int -> DestDefaults
toEnum 1 = DestDefaults
DestDefaultsMotion
    toEnum 2 = DestDefaults
DestDefaultsHighlight
    toEnum 4 = DestDefaults
DestDefaultsDrop
    toEnum 7 = DestDefaults
DestDefaultsAll
    toEnum k :: Int
k = Int -> DestDefaults
AnotherDestDefaults Int
k

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

foreign import ccall "gtk_dest_defaults_get_type" c_gtk_dest_defaults_get_type :: 
    IO GType

instance BoxedFlags DestDefaults where
    boxedFlagsType :: Proxy DestDefaults -> IO GType
boxedFlagsType _ = IO GType
c_gtk_dest_defaults_get_type

instance IsGFlag DestDefaults

-- Flags DebugFlag
-- | /No description available in the introspection data./
data DebugFlag = 
      DebugFlagText
    -- ^ /No description available in the introspection data./
    | DebugFlagTree
    -- ^ /No description available in the introspection data./
    | DebugFlagKeybindings
    -- ^ /No description available in the introspection data./
    | DebugFlagModules
    -- ^ /No description available in the introspection data./
    | DebugFlagGeometry
    -- ^ /No description available in the introspection data./
    | DebugFlagIcontheme
    -- ^ /No description available in the introspection data./
    | DebugFlagPrinting
    -- ^ /No description available in the introspection data./
    | DebugFlagBuilder
    -- ^ /No description available in the introspection data./
    | DebugFlagSizeRequest
    -- ^ /No description available in the introspection data./
    | DebugFlagNoCssCache
    -- ^ /No description available in the introspection data./
    | DebugFlagBaselines
    -- ^ /No description available in the introspection data./
    | DebugFlagInteractive
    -- ^ /No description available in the introspection data./
    | DebugFlagTouchscreen
    -- ^ /No description available in the introspection data./
    | DebugFlagActions
    -- ^ /No description available in the introspection data./
    | DebugFlagResize
    -- ^ /No description available in the introspection data./
    | DebugFlagLayout
    -- ^ /No description available in the introspection data./
    | DebugFlagSnapshot
    -- ^ /No description available in the introspection data./
    | AnotherDebugFlag Int
    -- ^ Catch-all for unknown values
    deriving (Int -> DebugFlag -> ShowS
[DebugFlag] -> ShowS
DebugFlag -> String
(Int -> DebugFlag -> ShowS)
-> (DebugFlag -> String)
-> ([DebugFlag] -> ShowS)
-> Show DebugFlag
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DebugFlag] -> ShowS
$cshowList :: [DebugFlag] -> ShowS
show :: DebugFlag -> String
$cshow :: DebugFlag -> String
showsPrec :: Int -> DebugFlag -> ShowS
$cshowsPrec :: Int -> DebugFlag -> ShowS
Show, DebugFlag -> DebugFlag -> Bool
(DebugFlag -> DebugFlag -> Bool)
-> (DebugFlag -> DebugFlag -> Bool) -> Eq DebugFlag
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DebugFlag -> DebugFlag -> Bool
$c/= :: DebugFlag -> DebugFlag -> Bool
== :: DebugFlag -> DebugFlag -> Bool
$c== :: DebugFlag -> DebugFlag -> Bool
Eq)

instance P.Enum DebugFlag where
    fromEnum :: DebugFlag -> Int
fromEnum DebugFlagText = 1
    fromEnum DebugFlagTree = 2
    fromEnum DebugFlagKeybindings = 4
    fromEnum DebugFlagModules = 8
    fromEnum DebugFlagGeometry = 16
    fromEnum DebugFlagIcontheme = 32
    fromEnum DebugFlagPrinting = 64
    fromEnum DebugFlagBuilder = 128
    fromEnum DebugFlagSizeRequest = 256
    fromEnum DebugFlagNoCssCache = 512
    fromEnum DebugFlagBaselines = 1024
    fromEnum DebugFlagInteractive = 2048
    fromEnum DebugFlagTouchscreen = 4096
    fromEnum DebugFlagActions = 8192
    fromEnum DebugFlagResize = 16384
    fromEnum DebugFlagLayout = 32768
    fromEnum DebugFlagSnapshot = 65536
    fromEnum (AnotherDebugFlag k :: Int
k) = Int
k

    toEnum :: Int -> DebugFlag
toEnum 1 = DebugFlag
DebugFlagText
    toEnum 2 = DebugFlag
DebugFlagTree
    toEnum 4 = DebugFlag
DebugFlagKeybindings
    toEnum 8 = DebugFlag
DebugFlagModules
    toEnum 16 = DebugFlag
DebugFlagGeometry
    toEnum 32 = DebugFlag
DebugFlagIcontheme
    toEnum 64 = DebugFlag
DebugFlagPrinting
    toEnum 128 = DebugFlag
DebugFlagBuilder
    toEnum 256 = DebugFlag
DebugFlagSizeRequest
    toEnum 512 = DebugFlag
DebugFlagNoCssCache
    toEnum 1024 = DebugFlag
DebugFlagBaselines
    toEnum 2048 = DebugFlag
DebugFlagInteractive
    toEnum 4096 = DebugFlag
DebugFlagTouchscreen
    toEnum 8192 = DebugFlag
DebugFlagActions
    toEnum 16384 = DebugFlag
DebugFlagResize
    toEnum 32768 = DebugFlag
DebugFlagLayout
    toEnum 65536 = DebugFlag
DebugFlagSnapshot
    toEnum k :: Int
k = Int -> DebugFlag
AnotherDebugFlag Int
k

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

foreign import ccall "gtk_debug_flag_get_type" c_gtk_debug_flag_get_type :: 
    IO GType

instance BoxedFlags DebugFlag where
    boxedFlagsType :: Proxy DebugFlag -> IO GType
boxedFlagsType _ = IO GType
c_gtk_debug_flag_get_type

instance IsGFlag DebugFlag

-- 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
showList :: [CellRendererState] -> ShowS
$cshowList :: [CellRendererState] -> ShowS
show :: CellRendererState -> String
$cshow :: CellRendererState -> String
showsPrec :: Int -> CellRendererState -> ShowS
$cshowsPrec :: Int -> CellRendererState -> ShowS
Show, CellRendererState -> CellRendererState -> Bool
(CellRendererState -> CellRendererState -> Bool)
-> (CellRendererState -> CellRendererState -> Bool)
-> Eq CellRendererState
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CellRendererState -> CellRendererState -> Bool
$c/= :: CellRendererState -> CellRendererState -> Bool
== :: CellRendererState -> CellRendererState -> Bool
$c== :: CellRendererState -> CellRendererState -> Bool
Eq)

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

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

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

foreign import ccall "gtk_cell_renderer_state_get_type" c_gtk_cell_renderer_state_get_type :: 
    IO GType

instance BoxedFlags CellRendererState where
    boxedFlagsType :: Proxy CellRendererState -> IO GType
boxedFlagsType _ = IO GType
c_gtk_cell_renderer_state_get_type

instance IsGFlag CellRendererState

-- Flags CalendarDisplayOptions
-- | These options can be used to influence the display and behaviour of a t'GI.Gtk.Objects.Calendar.Calendar'.
data CalendarDisplayOptions = 
      CalendarDisplayOptionsShowHeading
    -- ^ Specifies that the month and year should be displayed.
    | CalendarDisplayOptionsShowDayNames
    -- ^ Specifies that three letter day descriptions should be present.
    | CalendarDisplayOptionsNoMonthChange
    -- ^ Prevents the user from switching months with the calendar.
    | CalendarDisplayOptionsShowWeekNumbers
    -- ^ Displays each week numbers of the current year, down the
    -- left side of the calendar.
    | CalendarDisplayOptionsShowDetails
    -- ^ Just show an indicator, not the full details
    -- text when details are provided. See 'GI.Gtk.Objects.Calendar.calendarSetDetailFunc'.
    | AnotherCalendarDisplayOptions Int
    -- ^ Catch-all for unknown values
    deriving (Int -> CalendarDisplayOptions -> ShowS
[CalendarDisplayOptions] -> ShowS
CalendarDisplayOptions -> String
(Int -> CalendarDisplayOptions -> ShowS)
-> (CalendarDisplayOptions -> String)
-> ([CalendarDisplayOptions] -> ShowS)
-> Show CalendarDisplayOptions
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CalendarDisplayOptions] -> ShowS
$cshowList :: [CalendarDisplayOptions] -> ShowS
show :: CalendarDisplayOptions -> String
$cshow :: CalendarDisplayOptions -> String
showsPrec :: Int -> CalendarDisplayOptions -> ShowS
$cshowsPrec :: Int -> CalendarDisplayOptions -> ShowS
Show, CalendarDisplayOptions -> CalendarDisplayOptions -> Bool
(CalendarDisplayOptions -> CalendarDisplayOptions -> Bool)
-> (CalendarDisplayOptions -> CalendarDisplayOptions -> Bool)
-> Eq CalendarDisplayOptions
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CalendarDisplayOptions -> CalendarDisplayOptions -> Bool
$c/= :: CalendarDisplayOptions -> CalendarDisplayOptions -> Bool
== :: CalendarDisplayOptions -> CalendarDisplayOptions -> Bool
$c== :: CalendarDisplayOptions -> CalendarDisplayOptions -> Bool
Eq)

instance P.Enum CalendarDisplayOptions where
    fromEnum :: CalendarDisplayOptions -> Int
fromEnum CalendarDisplayOptionsShowHeading = 1
    fromEnum CalendarDisplayOptionsShowDayNames = 2
    fromEnum CalendarDisplayOptionsNoMonthChange = 4
    fromEnum CalendarDisplayOptionsShowWeekNumbers = 8
    fromEnum CalendarDisplayOptionsShowDetails = 32
    fromEnum (AnotherCalendarDisplayOptions k :: Int
k) = Int
k

    toEnum :: Int -> CalendarDisplayOptions
toEnum 1 = CalendarDisplayOptions
CalendarDisplayOptionsShowHeading
    toEnum 2 = CalendarDisplayOptions
CalendarDisplayOptionsShowDayNames
    toEnum 4 = CalendarDisplayOptions
CalendarDisplayOptionsNoMonthChange
    toEnum 8 = CalendarDisplayOptions
CalendarDisplayOptionsShowWeekNumbers
    toEnum 32 = CalendarDisplayOptions
CalendarDisplayOptionsShowDetails
    toEnum k :: Int
k = Int -> CalendarDisplayOptions
AnotherCalendarDisplayOptions Int
k

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

foreign import ccall "gtk_calendar_display_options_get_type" c_gtk_calendar_display_options_get_type :: 
    IO GType

instance BoxedFlags CalendarDisplayOptions where
    boxedFlagsType :: Proxy CalendarDisplayOptions -> IO GType
boxedFlagsType _ = IO GType
c_gtk_calendar_display_options_get_type

instance IsGFlag CalendarDisplayOptions

-- Flags ApplicationInhibitFlags
-- | Types of user actions that may be blocked by '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
showList :: [ApplicationInhibitFlags] -> ShowS
$cshowList :: [ApplicationInhibitFlags] -> ShowS
show :: ApplicationInhibitFlags -> String
$cshow :: ApplicationInhibitFlags -> String
showsPrec :: Int -> ApplicationInhibitFlags -> ShowS
$cshowsPrec :: Int -> ApplicationInhibitFlags -> ShowS
Show, ApplicationInhibitFlags -> ApplicationInhibitFlags -> Bool
(ApplicationInhibitFlags -> ApplicationInhibitFlags -> Bool)
-> (ApplicationInhibitFlags -> ApplicationInhibitFlags -> Bool)
-> Eq ApplicationInhibitFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ApplicationInhibitFlags -> ApplicationInhibitFlags -> Bool
$c/= :: ApplicationInhibitFlags -> ApplicationInhibitFlags -> Bool
== :: ApplicationInhibitFlags -> ApplicationInhibitFlags -> Bool
$c== :: ApplicationInhibitFlags -> ApplicationInhibitFlags -> Bool
Eq)

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

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

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

foreign import ccall "gtk_application_inhibit_flags_get_type" c_gtk_application_inhibit_flags_get_type :: 
    IO GType

instance BoxedFlags ApplicationInhibitFlags where
    boxedFlagsType :: Proxy ApplicationInhibitFlags -> IO GType
boxedFlagsType _ = IO GType
c_gtk_application_inhibit_flags_get_type

instance IsGFlag ApplicationInhibitFlags

-- Flags AccelFlags
-- | Accelerator flags used with 'GI.Gtk.Objects.AccelGroup.accelGroupConnect'.
data AccelFlags = 
      AccelFlagsVisible
    -- ^ Accelerator is visible
    | AccelFlagsLocked
    -- ^ Accelerator not removable
    | AccelFlagsMask
    -- ^ Mask
    | AnotherAccelFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> AccelFlags -> ShowS
[AccelFlags] -> ShowS
AccelFlags -> String
(Int -> AccelFlags -> ShowS)
-> (AccelFlags -> String)
-> ([AccelFlags] -> ShowS)
-> Show AccelFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AccelFlags] -> ShowS
$cshowList :: [AccelFlags] -> ShowS
show :: AccelFlags -> String
$cshow :: AccelFlags -> String
showsPrec :: Int -> AccelFlags -> ShowS
$cshowsPrec :: Int -> AccelFlags -> ShowS
Show, AccelFlags -> AccelFlags -> Bool
(AccelFlags -> AccelFlags -> Bool)
-> (AccelFlags -> AccelFlags -> Bool) -> Eq AccelFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AccelFlags -> AccelFlags -> Bool
$c/= :: AccelFlags -> AccelFlags -> Bool
== :: AccelFlags -> AccelFlags -> Bool
$c== :: AccelFlags -> AccelFlags -> Bool
Eq)

instance P.Enum AccelFlags where
    fromEnum :: AccelFlags -> Int
fromEnum AccelFlagsVisible = 1
    fromEnum AccelFlagsLocked = 2
    fromEnum AccelFlagsMask = 7
    fromEnum (AnotherAccelFlags k :: Int
k) = Int
k

    toEnum :: Int -> AccelFlags
toEnum 1 = AccelFlags
AccelFlagsVisible
    toEnum 2 = AccelFlags
AccelFlagsLocked
    toEnum 7 = AccelFlags
AccelFlagsMask
    toEnum k :: Int
k = Int -> AccelFlags
AnotherAccelFlags Int
k

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

foreign import ccall "gtk_accel_flags_get_type" c_gtk_accel_flags_get_type :: 
    IO GType

instance BoxedFlags AccelFlags where
    boxedFlagsType :: Proxy AccelFlags -> IO GType
boxedFlagsType _ = IO GType
c_gtk_accel_flags_get_type

instance IsGFlag AccelFlags