-- | 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(..)             ,


-- ** AttachOptions #flag:AttachOptions#

    AttachOptions(..)                       ,


-- ** 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(..)                          ,


-- ** JunctionSides #flag:JunctionSides#

    JunctionSides(..)                       ,


-- ** PlacesOpenFlags #flag:PlacesOpenFlags#

    PlacesOpenFlags(..)                     ,


-- ** RcFlags #flag:RcFlags#

    RcFlags(..)                             ,


-- ** RecentFilterFlags #flag:RecentFilterFlags#

    RecentFilterFlags(..)                   ,


-- ** RegionFlags #flag:RegionFlags#

    RegionFlags(..)                         ,


-- ** StateFlags #flag:StateFlags#

    StateFlags(..)                          ,


-- ** StyleContextPrintFlags #flag:StyleContextPrintFlags#

    StyleContextPrintFlags(..)              ,


-- ** TargetFlags #flag:TargetFlags#

    TargetFlags(..)                         ,


-- ** TextSearchFlags #flag:TextSearchFlags#

    TextSearchFlags(..)                     ,


-- ** ToolPaletteDragTargets #flag:ToolPaletteDragTargets#

    ToolPaletteDragTargets(..)              ,


-- ** TreeModelFlags #flag:TreeModelFlags#

    TreeModelFlags(..)                      ,


-- ** UIManagerItemType #flag:UIManagerItemType#

    UIManagerItemType(..)                   ,




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


-- Flags UIManagerItemType
{-# DEPRECATED UIManagerItemType ["(Since version 3.10)"] #-}
-- | These enumeration values are used by 'GI.Gtk.Objects.UIManager.uIManagerAddUi' to determine
-- what UI element to create.
data UIManagerItemType = 
      UIManagerItemTypeAuto
    -- ^ Pick the type of the UI element according to context.
    | UIManagerItemTypeMenubar
    -- ^ Create a menubar.
    | UIManagerItemTypeMenu
    -- ^ Create a menu.
    | UIManagerItemTypeToolbar
    -- ^ Create a toolbar.
    | UIManagerItemTypePlaceholder
    -- ^ Insert a placeholder.
    | UIManagerItemTypePopup
    -- ^ Create a popup menu.
    | UIManagerItemTypeMenuitem
    -- ^ Create a menuitem.
    | UIManagerItemTypeToolitem
    -- ^ Create a toolitem.
    | UIManagerItemTypeSeparator
    -- ^ Create a separator.
    | UIManagerItemTypeAccelerator
    -- ^ Install an accelerator.
    | UIManagerItemTypePopupWithAccels
    -- ^ Same as 'GI.Gtk.Flags.UIManagerItemTypePopup', but the
    --   actions’ accelerators are shown.
    | AnotherUIManagerItemType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> UIManagerItemType -> ShowS
[UIManagerItemType] -> ShowS
UIManagerItemType -> String
(Int -> UIManagerItemType -> ShowS)
-> (UIManagerItemType -> String)
-> ([UIManagerItemType] -> ShowS)
-> Show UIManagerItemType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [UIManagerItemType] -> ShowS
$cshowList :: [UIManagerItemType] -> ShowS
show :: UIManagerItemType -> String
$cshow :: UIManagerItemType -> String
showsPrec :: Int -> UIManagerItemType -> ShowS
$cshowsPrec :: Int -> UIManagerItemType -> ShowS
Show, UIManagerItemType -> UIManagerItemType -> Bool
(UIManagerItemType -> UIManagerItemType -> Bool)
-> (UIManagerItemType -> UIManagerItemType -> Bool)
-> Eq UIManagerItemType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UIManagerItemType -> UIManagerItemType -> Bool
$c/= :: UIManagerItemType -> UIManagerItemType -> Bool
== :: UIManagerItemType -> UIManagerItemType -> Bool
$c== :: UIManagerItemType -> UIManagerItemType -> Bool
Eq)

instance P.Enum UIManagerItemType where
    fromEnum :: UIManagerItemType -> Int
fromEnum UIManagerItemType
UIManagerItemTypeAuto = Int
0
    fromEnum UIManagerItemType
UIManagerItemTypeMenubar = Int
1
    fromEnum UIManagerItemType
UIManagerItemTypeMenu = Int
2
    fromEnum UIManagerItemType
UIManagerItemTypeToolbar = Int
4
    fromEnum UIManagerItemType
UIManagerItemTypePlaceholder = Int
8
    fromEnum UIManagerItemType
UIManagerItemTypePopup = Int
16
    fromEnum UIManagerItemType
UIManagerItemTypeMenuitem = Int
32
    fromEnum UIManagerItemType
UIManagerItemTypeToolitem = Int
64
    fromEnum UIManagerItemType
UIManagerItemTypeSeparator = Int
128
    fromEnum UIManagerItemType
UIManagerItemTypeAccelerator = Int
256
    fromEnum UIManagerItemType
UIManagerItemTypePopupWithAccels = Int
512
    fromEnum (AnotherUIManagerItemType Int
k) = Int
k

    toEnum :: Int -> UIManagerItemType
toEnum Int
0 = UIManagerItemType
UIManagerItemTypeAuto
    toEnum Int
1 = UIManagerItemType
UIManagerItemTypeMenubar
    toEnum Int
2 = UIManagerItemType
UIManagerItemTypeMenu
    toEnum Int
4 = UIManagerItemType
UIManagerItemTypeToolbar
    toEnum Int
8 = UIManagerItemType
UIManagerItemTypePlaceholder
    toEnum Int
16 = UIManagerItemType
UIManagerItemTypePopup
    toEnum Int
32 = UIManagerItemType
UIManagerItemTypeMenuitem
    toEnum Int
64 = UIManagerItemType
UIManagerItemTypeToolitem
    toEnum Int
128 = UIManagerItemType
UIManagerItemTypeSeparator
    toEnum Int
256 = UIManagerItemType
UIManagerItemTypeAccelerator
    toEnum Int
512 = UIManagerItemType
UIManagerItemTypePopupWithAccels
    toEnum Int
k = Int -> UIManagerItemType
AnotherUIManagerItemType Int
k

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

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

foreign import ccall "gtk_ui_manager_item_type_get_type" c_gtk_ui_manager_item_type_get_type :: 
    IO GType

instance B.Types.TypedObject UIManagerItemType where
    glibType :: IO GType
glibType = IO GType
c_gtk_ui_manager_item_type_get_type

instance B.Types.BoxedFlags UIManagerItemType

instance IsGFlag UIManagerItemType

-- 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 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 ToolPaletteDragTargets
-- | Flags used to specify the supported drag targets.
data ToolPaletteDragTargets = 
      ToolPaletteDragTargetsItems
    -- ^ Support drag of items.
    | ToolPaletteDragTargetsGroups
    -- ^ Support drag of groups.
    | AnotherToolPaletteDragTargets Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ToolPaletteDragTargets -> ShowS
[ToolPaletteDragTargets] -> ShowS
ToolPaletteDragTargets -> String
(Int -> ToolPaletteDragTargets -> ShowS)
-> (ToolPaletteDragTargets -> String)
-> ([ToolPaletteDragTargets] -> ShowS)
-> Show ToolPaletteDragTargets
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ToolPaletteDragTargets] -> ShowS
$cshowList :: [ToolPaletteDragTargets] -> ShowS
show :: ToolPaletteDragTargets -> String
$cshow :: ToolPaletteDragTargets -> String
showsPrec :: Int -> ToolPaletteDragTargets -> ShowS
$cshowsPrec :: Int -> ToolPaletteDragTargets -> ShowS
Show, ToolPaletteDragTargets -> ToolPaletteDragTargets -> Bool
(ToolPaletteDragTargets -> ToolPaletteDragTargets -> Bool)
-> (ToolPaletteDragTargets -> ToolPaletteDragTargets -> Bool)
-> Eq ToolPaletteDragTargets
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ToolPaletteDragTargets -> ToolPaletteDragTargets -> Bool
$c/= :: ToolPaletteDragTargets -> ToolPaletteDragTargets -> Bool
== :: ToolPaletteDragTargets -> ToolPaletteDragTargets -> Bool
$c== :: ToolPaletteDragTargets -> ToolPaletteDragTargets -> Bool
Eq)

instance P.Enum ToolPaletteDragTargets where
    fromEnum :: ToolPaletteDragTargets -> Int
fromEnum ToolPaletteDragTargets
ToolPaletteDragTargetsItems = Int
1
    fromEnum ToolPaletteDragTargets
ToolPaletteDragTargetsGroups = Int
2
    fromEnum (AnotherToolPaletteDragTargets Int
k) = Int
k

    toEnum :: Int -> ToolPaletteDragTargets
toEnum Int
1 = ToolPaletteDragTargets
ToolPaletteDragTargetsItems
    toEnum Int
2 = ToolPaletteDragTargets
ToolPaletteDragTargetsGroups
    toEnum Int
k = Int -> ToolPaletteDragTargets
AnotherToolPaletteDragTargets Int
k

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

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

foreign import ccall "gtk_tool_palette_drag_targets_get_type" c_gtk_tool_palette_drag_targets_get_type :: 
    IO GType

instance B.Types.TypedObject ToolPaletteDragTargets where
    glibType :: IO GType
glibType = IO GType
c_gtk_tool_palette_drag_targets_get_type

instance B.Types.BoxedFlags ToolPaletteDragTargets

instance IsGFlag ToolPaletteDragTargets

-- 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 pixbufs 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 pixbufs 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 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 TargetFlags
-- | The t'GI.Gtk.Flags.TargetFlags' enumeration is used to specify
-- constraints on a t'GI.Gtk.Structs.TargetEntry.TargetEntry'.
data TargetFlags = 
      TargetFlagsSameApp
    -- ^ If this is set, the target will only be selected
    --   for drags within a single application.
    | TargetFlagsSameWidget
    -- ^ If this is set, the target will only be selected
    --   for drags within a single widget.
    | TargetFlagsOtherApp
    -- ^ If this is set, the target will not be selected
    --   for drags within a single application.
    | TargetFlagsOtherWidget
    -- ^ If this is set, the target will not be selected
    --   for drags withing a single widget.
    | AnotherTargetFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> TargetFlags -> ShowS
[TargetFlags] -> ShowS
TargetFlags -> String
(Int -> TargetFlags -> ShowS)
-> (TargetFlags -> String)
-> ([TargetFlags] -> ShowS)
-> Show TargetFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TargetFlags] -> ShowS
$cshowList :: [TargetFlags] -> ShowS
show :: TargetFlags -> String
$cshow :: TargetFlags -> String
showsPrec :: Int -> TargetFlags -> ShowS
$cshowsPrec :: Int -> TargetFlags -> ShowS
Show, TargetFlags -> TargetFlags -> Bool
(TargetFlags -> TargetFlags -> Bool)
-> (TargetFlags -> TargetFlags -> Bool) -> Eq TargetFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TargetFlags -> TargetFlags -> Bool
$c/= :: TargetFlags -> TargetFlags -> Bool
== :: TargetFlags -> TargetFlags -> Bool
$c== :: TargetFlags -> TargetFlags -> Bool
Eq)

instance P.Enum TargetFlags where
    fromEnum :: TargetFlags -> Int
fromEnum TargetFlags
TargetFlagsSameApp = Int
1
    fromEnum TargetFlags
TargetFlagsSameWidget = Int
2
    fromEnum TargetFlags
TargetFlagsOtherApp = Int
4
    fromEnum TargetFlags
TargetFlagsOtherWidget = Int
8
    fromEnum (AnotherTargetFlags Int
k) = Int
k

    toEnum :: Int -> TargetFlags
toEnum Int
1 = TargetFlags
TargetFlagsSameApp
    toEnum Int
2 = TargetFlags
TargetFlagsSameWidget
    toEnum Int
4 = TargetFlags
TargetFlagsOtherApp
    toEnum Int
8 = TargetFlags
TargetFlagsOtherWidget
    toEnum Int
k = Int -> TargetFlags
AnotherTargetFlags Int
k

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

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

foreign import ccall "gtk_target_flags_get_type" c_gtk_target_flags_get_type :: 
    IO GType

instance B.Types.TypedObject TargetFlags where
    glibType :: IO GType
glibType = IO GType
c_gtk_target_flags_get_type

instance B.Types.BoxedFlags TargetFlags

instance IsGFlag TargetFlags

-- Flags StyleContextPrintFlags
-- | Flags that modify the behavior of 'GI.Gtk.Objects.StyleContext.styleContextToString'.
-- New values may be added to this enumeration.
data StyleContextPrintFlags = 
      StyleContextPrintFlagsNone
    -- ^ /No description available in the introspection data./
    | 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 StyleContextPrintFlags
StyleContextPrintFlagsNone = Int
0
    fromEnum StyleContextPrintFlags
StyleContextPrintFlagsRecurse = Int
1
    fromEnum StyleContextPrintFlags
StyleContextPrintFlagsShowStyle = Int
2
    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
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. Since 3.8
    | StateFlagsDirRtl
    -- ^ Widget is in right-to-left text direction. Since 3.8
    | StateFlagsLink
    -- ^ Widget is a link. Since 3.12
    | StateFlagsVisited
    -- ^ The location the widget points to has already been visited. Since 3.12
    | StateFlagsChecked
    -- ^ Widget is checked. Since 3.14
    | StateFlagsDropActive
    -- ^ Widget is highlighted as a drop target for DND. Since 3.20
    | 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 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 (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
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 RegionFlags
-- | Describes a region within a widget.
data RegionFlags = 
      RegionFlagsEven
    -- ^ Region has an even number within a set.
    | RegionFlagsOdd
    -- ^ Region has an odd number within a set.
    | RegionFlagsFirst
    -- ^ Region is the first one within a set.
    | RegionFlagsLast
    -- ^ Region is the last one within a set.
    | RegionFlagsOnly
    -- ^ Region is the only one within a set.
    | RegionFlagsSorted
    -- ^ Region is part of a sorted area.
    | AnotherRegionFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> RegionFlags -> ShowS
[RegionFlags] -> ShowS
RegionFlags -> String
(Int -> RegionFlags -> ShowS)
-> (RegionFlags -> String)
-> ([RegionFlags] -> ShowS)
-> Show RegionFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RegionFlags] -> ShowS
$cshowList :: [RegionFlags] -> ShowS
show :: RegionFlags -> String
$cshow :: RegionFlags -> String
showsPrec :: Int -> RegionFlags -> ShowS
$cshowsPrec :: Int -> RegionFlags -> ShowS
Show, RegionFlags -> RegionFlags -> Bool
(RegionFlags -> RegionFlags -> Bool)
-> (RegionFlags -> RegionFlags -> Bool) -> Eq RegionFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RegionFlags -> RegionFlags -> Bool
$c/= :: RegionFlags -> RegionFlags -> Bool
== :: RegionFlags -> RegionFlags -> Bool
$c== :: RegionFlags -> RegionFlags -> Bool
Eq)

instance P.Enum RegionFlags where
    fromEnum :: RegionFlags -> Int
fromEnum RegionFlags
RegionFlagsEven = Int
1
    fromEnum RegionFlags
RegionFlagsOdd = Int
2
    fromEnum RegionFlags
RegionFlagsFirst = Int
4
    fromEnum RegionFlags
RegionFlagsLast = Int
8
    fromEnum RegionFlags
RegionFlagsOnly = Int
16
    fromEnum RegionFlags
RegionFlagsSorted = Int
32
    fromEnum (AnotherRegionFlags Int
k) = Int
k

    toEnum :: Int -> RegionFlags
toEnum Int
1 = RegionFlags
RegionFlagsEven
    toEnum Int
2 = RegionFlags
RegionFlagsOdd
    toEnum Int
4 = RegionFlags
RegionFlagsFirst
    toEnum Int
8 = RegionFlags
RegionFlagsLast
    toEnum Int
16 = RegionFlags
RegionFlagsOnly
    toEnum Int
32 = RegionFlags
RegionFlagsSorted
    toEnum Int
k = Int -> RegionFlags
AnotherRegionFlags Int
k

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

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

foreign import ccall "gtk_region_flags_get_type" c_gtk_region_flags_get_type :: 
    IO GType

instance B.Types.TypedObject RegionFlags where
    glibType :: IO GType
glibType = IO GType
c_gtk_region_flags_get_type

instance B.Types.BoxedFlags RegionFlags

instance IsGFlag RegionFlags

-- Flags RecentFilterFlags
-- | These flags indicate what parts of a t'GI.Gtk.Structs.RecentFilterInfo.RecentFilterInfo' struct
-- are filled or need to be filled.
data RecentFilterFlags = 
      RecentFilterFlagsUri
    -- ^ the URI of the file being tested
    | RecentFilterFlagsDisplayName
    -- ^ the string that will be used to
    --  display the file in the recent chooser
    | RecentFilterFlagsMimeType
    -- ^ the mime type of the file
    | RecentFilterFlagsApplication
    -- ^ the list of applications that have
    --  registered the file
    | RecentFilterFlagsGroup
    -- ^ the groups to which the file belongs to
    | RecentFilterFlagsAge
    -- ^ the number of days elapsed since the file
    --  has been registered
    | AnotherRecentFilterFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> RecentFilterFlags -> ShowS
[RecentFilterFlags] -> ShowS
RecentFilterFlags -> String
(Int -> RecentFilterFlags -> ShowS)
-> (RecentFilterFlags -> String)
-> ([RecentFilterFlags] -> ShowS)
-> Show RecentFilterFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RecentFilterFlags] -> ShowS
$cshowList :: [RecentFilterFlags] -> ShowS
show :: RecentFilterFlags -> String
$cshow :: RecentFilterFlags -> String
showsPrec :: Int -> RecentFilterFlags -> ShowS
$cshowsPrec :: Int -> RecentFilterFlags -> ShowS
Show, RecentFilterFlags -> RecentFilterFlags -> Bool
(RecentFilterFlags -> RecentFilterFlags -> Bool)
-> (RecentFilterFlags -> RecentFilterFlags -> Bool)
-> Eq RecentFilterFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RecentFilterFlags -> RecentFilterFlags -> Bool
$c/= :: RecentFilterFlags -> RecentFilterFlags -> Bool
== :: RecentFilterFlags -> RecentFilterFlags -> Bool
$c== :: RecentFilterFlags -> RecentFilterFlags -> Bool
Eq)

instance P.Enum RecentFilterFlags where
    fromEnum :: RecentFilterFlags -> Int
fromEnum RecentFilterFlags
RecentFilterFlagsUri = Int
1
    fromEnum RecentFilterFlags
RecentFilterFlagsDisplayName = Int
2
    fromEnum RecentFilterFlags
RecentFilterFlagsMimeType = Int
4
    fromEnum RecentFilterFlags
RecentFilterFlagsApplication = Int
8
    fromEnum RecentFilterFlags
RecentFilterFlagsGroup = Int
16
    fromEnum RecentFilterFlags
RecentFilterFlagsAge = Int
32
    fromEnum (AnotherRecentFilterFlags Int
k) = Int
k

    toEnum :: Int -> RecentFilterFlags
toEnum Int
1 = RecentFilterFlags
RecentFilterFlagsUri
    toEnum Int
2 = RecentFilterFlags
RecentFilterFlagsDisplayName
    toEnum Int
4 = RecentFilterFlags
RecentFilterFlagsMimeType
    toEnum Int
8 = RecentFilterFlags
RecentFilterFlagsApplication
    toEnum Int
16 = RecentFilterFlags
RecentFilterFlagsGroup
    toEnum Int
32 = RecentFilterFlags
RecentFilterFlagsAge
    toEnum Int
k = Int -> RecentFilterFlags
AnotherRecentFilterFlags Int
k

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

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

foreign import ccall "gtk_recent_filter_flags_get_type" c_gtk_recent_filter_flags_get_type :: 
    IO GType

instance B.Types.TypedObject RecentFilterFlags where
    glibType :: IO GType
glibType = IO GType
c_gtk_recent_filter_flags_get_type

instance B.Types.BoxedFlags RecentFilterFlags

instance IsGFlag RecentFilterFlags

-- Flags RcFlags
-- | Deprecated
data RcFlags = 
      RcFlagsFg
    -- ^ Deprecated
    | RcFlagsBg
    -- ^ Deprecated
    | RcFlagsText
    -- ^ Deprecated
    | RcFlagsBase
    -- ^ Deprecated
    | AnotherRcFlags Int
    -- ^ Catch-all for unknown values
    deriving (Int -> RcFlags -> ShowS
[RcFlags] -> ShowS
RcFlags -> String
(Int -> RcFlags -> ShowS)
-> (RcFlags -> String) -> ([RcFlags] -> ShowS) -> Show RcFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RcFlags] -> ShowS
$cshowList :: [RcFlags] -> ShowS
show :: RcFlags -> String
$cshow :: RcFlags -> String
showsPrec :: Int -> RcFlags -> ShowS
$cshowsPrec :: Int -> RcFlags -> ShowS
Show, RcFlags -> RcFlags -> Bool
(RcFlags -> RcFlags -> Bool)
-> (RcFlags -> RcFlags -> Bool) -> Eq RcFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RcFlags -> RcFlags -> Bool
$c/= :: RcFlags -> RcFlags -> Bool
== :: RcFlags -> RcFlags -> Bool
$c== :: RcFlags -> RcFlags -> Bool
Eq)

instance P.Enum RcFlags where
    fromEnum :: RcFlags -> Int
fromEnum RcFlags
RcFlagsFg = Int
1
    fromEnum RcFlags
RcFlagsBg = Int
2
    fromEnum RcFlags
RcFlagsText = Int
4
    fromEnum RcFlags
RcFlagsBase = Int
8
    fromEnum (AnotherRcFlags Int
k) = Int
k

    toEnum :: Int -> RcFlags
toEnum Int
1 = RcFlags
RcFlagsFg
    toEnum Int
2 = RcFlags
RcFlagsBg
    toEnum Int
4 = RcFlags
RcFlagsText
    toEnum Int
8 = RcFlags
RcFlagsBase
    toEnum Int
k = Int -> RcFlags
AnotherRcFlags Int
k

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

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

foreign import ccall "gtk_rc_flags_get_type" c_gtk_rc_flags_get_type :: 
    IO GType

instance B.Types.TypedObject RcFlags where
    glibType :: IO GType
glibType = IO GType
c_gtk_rc_flags_get_type

instance B.Types.BoxedFlags RcFlags

instance IsGFlag RcFlags

-- Flags PlacesOpenFlags
-- | These flags serve two purposes.  First, the application can call 'GI.Gtk.Objects.PlacesSidebar.placesSidebarSetOpenFlags'
-- using these flags as a bitmask.  This tells the sidebar that the application is able to open
-- folders selected from the sidebar in various ways, for example, in new tabs or in new windows in
-- addition to the normal mode.
-- 
-- Second, when one of these values gets passed back to the application in the
-- [openLocation]("GI.Gtk.Objects.PlacesSidebar#g:signal:openLocation") signal, it means that the application should
-- open the selected location in the normal way, in a new tab, or in a new
-- window.  The sidebar takes care of determining the desired way to open the location,
-- based on the modifier keys that the user is pressing at the time the selection is made.
-- 
-- If the application never calls 'GI.Gtk.Objects.PlacesSidebar.placesSidebarSetOpenFlags', then the sidebar will only
-- use @/GTK_PLACES_OPEN_NORMAL/@ in the [openLocation]("GI.Gtk.Objects.PlacesSidebar#g:signal:openLocation") signal.  This is the
-- default mode of operation.
data PlacesOpenFlags = 
      PlacesOpenFlagsNormal
    -- ^ This is the default mode that t'GI.Gtk.Objects.PlacesSidebar.PlacesSidebar' uses if no other flags
    --  are specified.  It indicates that the calling application should open the selected location
    --  in the normal way, for example, in the folder view beside the sidebar.
    | PlacesOpenFlagsNewTab
    -- ^ When passed to 'GI.Gtk.Objects.PlacesSidebar.placesSidebarSetOpenFlags', this indicates
    --  that the application can open folders selected from the sidebar in new tabs.  This value
    --  will be passed to the [openLocation]("GI.Gtk.Objects.PlacesSidebar#g:signal:openLocation") signal when the user selects
    --  that a location be opened in a new tab instead of in the standard fashion.
    | PlacesOpenFlagsNewWindow
    -- ^ Similar to /@gTKPLACESOPENNEWTAB@/, but indicates that the application
    --  can open folders in new windows.
    | 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 PlacesOpenFlags
PlacesOpenFlagsNormal = Int
1
    fromEnum PlacesOpenFlags
PlacesOpenFlagsNewTab = Int
2
    fromEnum PlacesOpenFlags
PlacesOpenFlagsNewWindow = Int
4
    fromEnum (AnotherPlacesOpenFlags Int
k) = Int
k

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

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

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

foreign import ccall "gtk_places_open_flags_get_type" c_gtk_places_open_flags_get_type :: 
    IO GType

instance B.Types.TypedObject PlacesOpenFlags where
    glibType :: IO GType
glibType = IO GType
c_gtk_places_open_flags_get_type

instance B.Types.BoxedFlags PlacesOpenFlags

instance IsGFlag PlacesOpenFlags

-- Flags JunctionSides
-- | Describes how a rendered element connects to adjacent elements.
data JunctionSides = 
      JunctionSidesNone
    -- ^ No junctions.
    | JunctionSidesCornerTopleft
    -- ^ Element connects on the top-left corner.
    | JunctionSidesCornerTopright
    -- ^ Element connects on the top-right corner.
    | JunctionSidesCornerBottomleft
    -- ^ Element connects on the bottom-left corner.
    | JunctionSidesCornerBottomright
    -- ^ Element connects on the bottom-right corner.
    | JunctionSidesTop
    -- ^ Element connects on the top side.
    | JunctionSidesBottom
    -- ^ Element connects on the bottom side.
    | JunctionSidesLeft
    -- ^ Element connects on the left side.
    | JunctionSidesRight
    -- ^ Element connects on the right side.
    | AnotherJunctionSides Int
    -- ^ Catch-all for unknown values
    deriving (Int -> JunctionSides -> ShowS
[JunctionSides] -> ShowS
JunctionSides -> String
(Int -> JunctionSides -> ShowS)
-> (JunctionSides -> String)
-> ([JunctionSides] -> ShowS)
-> Show JunctionSides
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [JunctionSides] -> ShowS
$cshowList :: [JunctionSides] -> ShowS
show :: JunctionSides -> String
$cshow :: JunctionSides -> String
showsPrec :: Int -> JunctionSides -> ShowS
$cshowsPrec :: Int -> JunctionSides -> ShowS
Show, JunctionSides -> JunctionSides -> Bool
(JunctionSides -> JunctionSides -> Bool)
-> (JunctionSides -> JunctionSides -> Bool) -> Eq JunctionSides
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: JunctionSides -> JunctionSides -> Bool
$c/= :: JunctionSides -> JunctionSides -> Bool
== :: JunctionSides -> JunctionSides -> Bool
$c== :: JunctionSides -> JunctionSides -> Bool
Eq)

instance P.Enum JunctionSides where
    fromEnum :: JunctionSides -> Int
fromEnum JunctionSides
JunctionSidesNone = Int
0
    fromEnum JunctionSides
JunctionSidesCornerTopleft = Int
1
    fromEnum JunctionSides
JunctionSidesCornerTopright = Int
2
    fromEnum JunctionSides
JunctionSidesCornerBottomleft = Int
4
    fromEnum JunctionSides
JunctionSidesCornerBottomright = Int
8
    fromEnum JunctionSides
JunctionSidesTop = Int
3
    fromEnum JunctionSides
JunctionSidesBottom = Int
12
    fromEnum JunctionSides
JunctionSidesLeft = Int
5
    fromEnum JunctionSides
JunctionSidesRight = Int
10
    fromEnum (AnotherJunctionSides Int
k) = Int
k

    toEnum :: Int -> JunctionSides
toEnum Int
0 = JunctionSides
JunctionSidesNone
    toEnum Int
1 = JunctionSides
JunctionSidesCornerTopleft
    toEnum Int
2 = JunctionSides
JunctionSidesCornerTopright
    toEnum Int
4 = JunctionSides
JunctionSidesCornerBottomleft
    toEnum Int
8 = JunctionSides
JunctionSidesCornerBottomright
    toEnum Int
3 = JunctionSides
JunctionSidesTop
    toEnum Int
12 = JunctionSides
JunctionSidesBottom
    toEnum Int
5 = JunctionSides
JunctionSidesLeft
    toEnum Int
10 = JunctionSides
JunctionSidesRight
    toEnum Int
k = Int -> JunctionSides
AnotherJunctionSides Int
k

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

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

foreign import ccall "gtk_junction_sides_get_type" c_gtk_junction_sides_get_type :: 
    IO GType

instance B.Types.TypedObject JunctionSides where
    glibType :: IO GType
glibType = IO GType
c_gtk_junction_sides_get_type

instance B.Types.BoxedFlags JunctionSides

instance IsGFlag JunctionSides

-- 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.
-- 
-- /Since: 3.6/
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. Since 3.18
    | InputHintsEmoji
    -- ^ Suggest offering Emoji support. Since 3.22.20
    | InputHintsNoEmoji
    -- ^ Suggest not offering Emoji support. Since 3.22.20
    | 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 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 (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
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 = 
      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 'GI.Gtk.Objects.IconInfo.iconInfoGetBuiltinPixbuf'.
    | 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'. Since 2.12.
    | IconLookupFlagsForceSize
    -- ^ Always get the icon scaled to the
    --   requested size. Since 2.14.
    | IconLookupFlagsForceRegular
    -- ^ Try to always load regular icons, even
    --   when symbolic icon names are given. Since 3.14.
    | IconLookupFlagsForceSymbolic
    -- ^ Try to always load symbolic icons, even
    --   when regular icon names are given. Since 3.14.
    | IconLookupFlagsDirLtr
    -- ^ Try to load a variant of the icon for left-to-right
    --   text direction. Since 3.14.
    | IconLookupFlagsDirRtl
    -- ^ Try to load a variant of the icon for right-to-left
    --   text direction. Since 3.14.
    | 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 IconLookupFlags
IconLookupFlagsNoSvg = Int
1
    fromEnum IconLookupFlags
IconLookupFlagsForceSvg = Int
2
    fromEnum IconLookupFlags
IconLookupFlagsUseBuiltin = Int
4
    fromEnum IconLookupFlags
IconLookupFlagsGenericFallback = Int
8
    fromEnum IconLookupFlags
IconLookupFlagsForceSize = Int
16
    fromEnum IconLookupFlags
IconLookupFlagsForceRegular = Int
32
    fromEnum IconLookupFlags
IconLookupFlagsForceSymbolic = Int
64
    fromEnum IconLookupFlags
IconLookupFlagsDirLtr = Int
128
    fromEnum IconLookupFlags
IconLookupFlagsDirRtl = Int
256
    fromEnum (AnotherIconLookupFlags Int
k) = Int
k

    toEnum :: Int -> IconLookupFlags
toEnum Int
1 = IconLookupFlags
IconLookupFlagsNoSvg
    toEnum Int
2 = IconLookupFlags
IconLookupFlagsForceSvg
    toEnum Int
4 = IconLookupFlags
IconLookupFlagsUseBuiltin
    toEnum Int
8 = IconLookupFlags
IconLookupFlagsGenericFallback
    toEnum Int
16 = IconLookupFlags
IconLookupFlagsForceSize
    toEnum Int
32 = IconLookupFlags
IconLookupFlagsForceRegular
    toEnum Int
64 = IconLookupFlags
IconLookupFlagsForceSymbolic
    toEnum Int
128 = IconLookupFlags
IconLookupFlagsDirLtr
    toEnum Int
256 = IconLookupFlags
IconLookupFlagsDirRtl
    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
-- | 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
    -- ^ /No description available in the introspection data./
    | 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 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 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 FileFilterFlags
FileFilterFlagsFilename = Int
1
    fromEnum FileFilterFlags
FileFilterFlagsUri = Int
2
    fromEnum FileFilterFlags
FileFilterFlagsDisplayName = Int
4
    fromEnum FileFilterFlags
FileFilterFlagsMimeType = Int
8
    fromEnum (AnotherFileFilterFlags Int
k) = Int
k

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

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

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

foreign import ccall "gtk_file_filter_flags_get_type" c_gtk_file_filter_flags_get_type :: 
    IO GType

instance B.Types.TypedObject FileFilterFlags where
    glibType :: IO GType
glibType = IO GType
c_gtk_file_filter_flags_get_type

instance B.Types.BoxedFlags FileFilterFlags

instance IsGFlag FileFilterFlags

-- Flags EventControllerScrollFlags
-- | Describes the behavior of a t'GI.Gtk.Objects.EventControllerScroll.EventControllerScroll'.
-- 
-- /Since: 3.24/
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#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
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 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,
    --     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. Since 3.12.
    | 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 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 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 targets
    --   and actions.
    --   GTK+ will then call 'GI.Gdk.Functions.dragStatus' 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 targets 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 'GI.Gtk.Functions.dragFinish'. If
    --   the action was a move, then if the drag was successful, then 'P.True' will be
    --   passed for the /@delete@/ parameter to 'GI.Gtk.Functions.dragFinish'.
    | 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 DestDefaults
DestDefaultsMotion = Int
1
    fromEnum DestDefaults
DestDefaultsHighlight = Int
2
    fromEnum DestDefaults
DestDefaultsDrop = Int
4
    fromEnum DestDefaults
DestDefaultsAll = Int
7
    fromEnum (AnotherDestDefaults Int
k) = Int
k

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

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

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

foreign import ccall "gtk_dest_defaults_get_type" c_gtk_dest_defaults_get_type :: 
    IO GType

instance B.Types.TypedObject DestDefaults where
    glibType :: IO GType
glibType = IO GType
c_gtk_dest_defaults_get_type

instance B.Types.BoxedFlags DestDefaults

instance IsGFlag DestDefaults

-- Flags DebugFlag
-- | /No description available in the introspection data./
data DebugFlag = 
      DebugFlagMisc
    -- ^ /No description available in the introspection data./
    | DebugFlagPlugsocket
    -- ^ /No description available in the introspection data./
    | DebugFlagText
    -- ^ /No description available in the introspection data./
    | DebugFlagTree
    -- ^ /No description available in the introspection data./
    | DebugFlagUpdates
    -- ^ /No description available in the introspection data./
    | DebugFlagKeybindings
    -- ^ /No description available in the introspection data./
    | DebugFlagMultihead
    -- ^ /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./
    | DebugFlagPixelCache
    -- ^ /No description available in the introspection data./
    | DebugFlagNoPixelCache
    -- ^ /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./
    | 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 DebugFlag
DebugFlagMisc = Int
1
    fromEnum DebugFlag
DebugFlagPlugsocket = Int
2
    fromEnum DebugFlag
DebugFlagText = Int
4
    fromEnum DebugFlag
DebugFlagTree = Int
8
    fromEnum DebugFlag
DebugFlagUpdates = Int
16
    fromEnum DebugFlag
DebugFlagKeybindings = Int
32
    fromEnum DebugFlag
DebugFlagMultihead = Int
64
    fromEnum DebugFlag
DebugFlagModules = Int
128
    fromEnum DebugFlag
DebugFlagGeometry = Int
256
    fromEnum DebugFlag
DebugFlagIcontheme = Int
512
    fromEnum DebugFlag
DebugFlagPrinting = Int
1024
    fromEnum DebugFlag
DebugFlagBuilder = Int
2048
    fromEnum DebugFlag
DebugFlagSizeRequest = Int
4096
    fromEnum DebugFlag
DebugFlagNoCssCache = Int
8192
    fromEnum DebugFlag
DebugFlagBaselines = Int
16384
    fromEnum DebugFlag
DebugFlagPixelCache = Int
32768
    fromEnum DebugFlag
DebugFlagNoPixelCache = Int
65536
    fromEnum DebugFlag
DebugFlagInteractive = Int
131072
    fromEnum DebugFlag
DebugFlagTouchscreen = Int
262144
    fromEnum DebugFlag
DebugFlagActions = Int
524288
    fromEnum DebugFlag
DebugFlagResize = Int
1048576
    fromEnum DebugFlag
DebugFlagLayout = Int
2097152
    fromEnum (AnotherDebugFlag Int
k) = Int
k

    toEnum :: Int -> DebugFlag
toEnum Int
1 = DebugFlag
DebugFlagMisc
    toEnum Int
2 = DebugFlag
DebugFlagPlugsocket
    toEnum Int
4 = DebugFlag
DebugFlagText
    toEnum Int
8 = DebugFlag
DebugFlagTree
    toEnum Int
16 = DebugFlag
DebugFlagUpdates
    toEnum Int
32 = DebugFlag
DebugFlagKeybindings
    toEnum Int
64 = DebugFlag
DebugFlagMultihead
    toEnum Int
128 = DebugFlag
DebugFlagModules
    toEnum Int
256 = DebugFlag
DebugFlagGeometry
    toEnum Int
512 = DebugFlag
DebugFlagIcontheme
    toEnum Int
1024 = DebugFlag
DebugFlagPrinting
    toEnum Int
2048 = DebugFlag
DebugFlagBuilder
    toEnum Int
4096 = DebugFlag
DebugFlagSizeRequest
    toEnum Int
8192 = DebugFlag
DebugFlagNoCssCache
    toEnum Int
16384 = DebugFlag
DebugFlagBaselines
    toEnum Int
32768 = DebugFlag
DebugFlagPixelCache
    toEnum Int
65536 = DebugFlag
DebugFlagNoPixelCache
    toEnum Int
131072 = DebugFlag
DebugFlagInteractive
    toEnum Int
262144 = DebugFlag
DebugFlagTouchscreen
    toEnum Int
524288 = DebugFlag
DebugFlagActions
    toEnum Int
1048576 = DebugFlag
DebugFlagResize
    toEnum Int
2097152 = DebugFlag
DebugFlagLayout
    toEnum Int
k = Int -> DebugFlag
AnotherDebugFlag Int
k

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

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

foreign import ccall "gtk_debug_flag_get_type" c_gtk_debug_flag_get_type :: 
    IO GType

instance B.Types.TypedObject DebugFlag where
    glibType :: IO GType
glibType = IO GType
c_gtk_debug_flag_get_type

instance B.Types.BoxedFlags DebugFlag

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. Since 3.4
    | CellRendererStateExpanded
    -- ^ The cell is in a row that is expanded. Since 3.4
    | 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 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 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 CalendarDisplayOptions
CalendarDisplayOptionsShowHeading = Int
1
    fromEnum CalendarDisplayOptions
CalendarDisplayOptionsShowDayNames = Int
2
    fromEnum CalendarDisplayOptions
CalendarDisplayOptionsNoMonthChange = Int
4
    fromEnum CalendarDisplayOptions
CalendarDisplayOptionsShowWeekNumbers = Int
8
    fromEnum CalendarDisplayOptions
CalendarDisplayOptionsShowDetails = Int
32
    fromEnum (AnotherCalendarDisplayOptions Int
k) = Int
k

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

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

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

foreign import ccall "gtk_calendar_display_options_get_type" c_gtk_calendar_display_options_get_type :: 
    IO GType

instance B.Types.TypedObject CalendarDisplayOptions where
    glibType :: IO GType
glibType = IO GType
c_gtk_calendar_display_options_get_type

instance B.Types.BoxedFlags CalendarDisplayOptions

instance IsGFlag CalendarDisplayOptions

-- Flags AttachOptions
-- | Denotes the expansion properties that a widget will have when it (or its
-- parent) is resized.
data AttachOptions = 
      AttachOptionsExpand
    -- ^ the widget should expand to take up any extra space in its
    -- container that has been allocated.
    | AttachOptionsShrink
    -- ^ the widget should shrink as and when possible.
    | AttachOptionsFill
    -- ^ the widget should fill the space allocated to it.
    | AnotherAttachOptions Int
    -- ^ Catch-all for unknown values
    deriving (Int -> AttachOptions -> ShowS
[AttachOptions] -> ShowS
AttachOptions -> String
(Int -> AttachOptions -> ShowS)
-> (AttachOptions -> String)
-> ([AttachOptions] -> ShowS)
-> Show AttachOptions
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AttachOptions] -> ShowS
$cshowList :: [AttachOptions] -> ShowS
show :: AttachOptions -> String
$cshow :: AttachOptions -> String
showsPrec :: Int -> AttachOptions -> ShowS
$cshowsPrec :: Int -> AttachOptions -> ShowS
Show, AttachOptions -> AttachOptions -> Bool
(AttachOptions -> AttachOptions -> Bool)
-> (AttachOptions -> AttachOptions -> Bool) -> Eq AttachOptions
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AttachOptions -> AttachOptions -> Bool
$c/= :: AttachOptions -> AttachOptions -> Bool
== :: AttachOptions -> AttachOptions -> Bool
$c== :: AttachOptions -> AttachOptions -> Bool
Eq)

instance P.Enum AttachOptions where
    fromEnum :: AttachOptions -> Int
fromEnum AttachOptions
AttachOptionsExpand = Int
1
    fromEnum AttachOptions
AttachOptionsShrink = Int
2
    fromEnum AttachOptions
AttachOptionsFill = Int
4
    fromEnum (AnotherAttachOptions Int
k) = Int
k

    toEnum :: Int -> AttachOptions
toEnum Int
1 = AttachOptions
AttachOptionsExpand
    toEnum Int
2 = AttachOptions
AttachOptionsShrink
    toEnum Int
4 = AttachOptions
AttachOptionsFill
    toEnum Int
k = Int -> AttachOptions
AnotherAttachOptions Int
k

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

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

foreign import ccall "gtk_attach_options_get_type" c_gtk_attach_options_get_type :: 
    IO GType

instance B.Types.TypedObject AttachOptions where
    glibType :: IO GType
glibType = IO GType
c_gtk_attach_options_get_type

instance B.Types.BoxedFlags AttachOptions

instance IsGFlag AttachOptions

-- Flags ApplicationInhibitFlags
-- | Types of user actions that may be blocked by 'GI.Gtk.Objects.Application.applicationInhibit'.
-- 
-- /Since: 3.4/
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 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

-- 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 AccelFlags
AccelFlagsVisible = Int
1
    fromEnum AccelFlags
AccelFlagsLocked = Int
2
    fromEnum AccelFlags
AccelFlagsMask = Int
7
    fromEnum (AnotherAccelFlags Int
k) = Int
k

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

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

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

foreign import ccall "gtk_accel_flags_get_type" c_gtk_accel_flags_get_type :: 
    IO GType

instance B.Types.TypedObject AccelFlags where
    glibType :: IO GType
glibType = IO GType
c_gtk_accel_flags_get_type

instance B.Types.BoxedFlags AccelFlags

instance IsGFlag AccelFlags