-- | 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.Enums
    ( 

 -- * Enumerations
-- ** Align #enum:Align#

    Align(..)                               ,


-- ** ArrowPlacement #enum:ArrowPlacement#

    ArrowPlacement(..)                      ,


-- ** ArrowType #enum:ArrowType#

    ArrowType(..)                           ,


-- ** AssistantPageType #enum:AssistantPageType#

    AssistantPageType(..)                   ,


-- ** BaselinePosition #enum:BaselinePosition#

    BaselinePosition(..)                    ,


-- ** BorderStyle #enum:BorderStyle#

    BorderStyle(..)                         ,


-- ** BuilderError #enum:BuilderError#

    BuilderError(..)                        ,
    catchBuilderError                       ,
    handleBuilderError                      ,


-- ** ButtonBoxStyle #enum:ButtonBoxStyle#

    ButtonBoxStyle(..)                      ,


-- ** ButtonRole #enum:ButtonRole#

    ButtonRole(..)                          ,


-- ** ButtonsType #enum:ButtonsType#

    ButtonsType(..)                         ,


-- ** CellRendererAccelMode #enum:CellRendererAccelMode#

    CellRendererAccelMode(..)               ,


-- ** CellRendererMode #enum:CellRendererMode#

    CellRendererMode(..)                    ,


-- ** CornerType #enum:CornerType#

    CornerType(..)                          ,


-- ** CssProviderError #enum:CssProviderError#

    CssProviderError(..)                    ,
    catchCssProviderError                   ,
    handleCssProviderError                  ,


-- ** CssSectionType #enum:CssSectionType#

    CssSectionType(..)                      ,


-- ** DeleteType #enum:DeleteType#

    DeleteType(..)                          ,


-- ** DirectionType #enum:DirectionType#

    DirectionType(..)                       ,


-- ** DragResult #enum:DragResult#

    DragResult(..)                          ,


-- ** EntryIconPosition #enum:EntryIconPosition#

    EntryIconPosition(..)                   ,


-- ** EventSequenceState #enum:EventSequenceState#

    EventSequenceState(..)                  ,


-- ** ExpanderStyle #enum:ExpanderStyle#

    ExpanderStyle(..)                       ,


-- ** FileChooserAction #enum:FileChooserAction#

    FileChooserAction(..)                   ,


-- ** FileChooserConfirmation #enum:FileChooserConfirmation#

    FileChooserConfirmation(..)             ,


-- ** FileChooserError #enum:FileChooserError#

    FileChooserError(..)                    ,
    catchFileChooserError                   ,
    handleFileChooserError                  ,


-- ** IMPreeditStyle #enum:IMPreeditStyle#

    IMPreeditStyle(..)                      ,


-- ** IMStatusStyle #enum:IMStatusStyle#

    IMStatusStyle(..)                       ,


-- ** IconSize #enum:IconSize#

    IconSize(..)                            ,


-- ** IconThemeError #enum:IconThemeError#

    IconThemeError(..)                      ,
    catchIconThemeError                     ,
    handleIconThemeError                    ,


-- ** IconViewDropPosition #enum:IconViewDropPosition#

    IconViewDropPosition(..)                ,


-- ** ImageType #enum:ImageType#

    ImageType(..)                           ,


-- ** InputPurpose #enum:InputPurpose#

    InputPurpose(..)                        ,


-- ** Justification #enum:Justification#

    Justification(..)                       ,


-- ** LevelBarMode #enum:LevelBarMode#

    LevelBarMode(..)                        ,


-- ** License #enum:License#

    License(..)                             ,


-- ** MenuDirectionType #enum:MenuDirectionType#

    MenuDirectionType(..)                   ,


-- ** MessageType #enum:MessageType#

    MessageType(..)                         ,


-- ** MovementStep #enum:MovementStep#

    MovementStep(..)                        ,


-- ** NotebookTab #enum:NotebookTab#

    NotebookTab(..)                         ,


-- ** NumberUpLayout #enum:NumberUpLayout#

    NumberUpLayout(..)                      ,


-- ** Orientation #enum:Orientation#

    Orientation(..)                         ,


-- ** PackDirection #enum:PackDirection#

    PackDirection(..)                       ,


-- ** PackType #enum:PackType#

    PackType(..)                            ,


-- ** PadActionType #enum:PadActionType#

    PadActionType(..)                       ,


-- ** PageOrientation #enum:PageOrientation#

    PageOrientation(..)                     ,


-- ** PageSet #enum:PageSet#

    PageSet(..)                             ,


-- ** PanDirection #enum:PanDirection#

    PanDirection(..)                        ,


-- ** PathPriorityType #enum:PathPriorityType#

    PathPriorityType(..)                    ,


-- ** PathType #enum:PathType#

    PathType(..)                            ,


-- ** PolicyType #enum:PolicyType#

    PolicyType(..)                          ,


-- ** PopoverConstraint #enum:PopoverConstraint#

    PopoverConstraint(..)                   ,


-- ** PositionType #enum:PositionType#

    PositionType(..)                        ,


-- ** PrintDuplex #enum:PrintDuplex#

    PrintDuplex(..)                         ,


-- ** PrintError #enum:PrintError#

    PrintError(..)                          ,
    catchPrintError                         ,
    handlePrintError                        ,


-- ** PrintOperationAction #enum:PrintOperationAction#

    PrintOperationAction(..)                ,


-- ** PrintOperationResult #enum:PrintOperationResult#

    PrintOperationResult(..)                ,


-- ** PrintPages #enum:PrintPages#

    PrintPages(..)                          ,


-- ** PrintQuality #enum:PrintQuality#

    PrintQuality(..)                        ,


-- ** PrintStatus #enum:PrintStatus#

    PrintStatus(..)                         ,


-- ** PropagationPhase #enum:PropagationPhase#

    PropagationPhase(..)                    ,


-- ** RcTokenType #enum:RcTokenType#

    RcTokenType(..)                         ,


-- ** RecentChooserError #enum:RecentChooserError#

    RecentChooserError(..)                  ,
    catchRecentChooserError                 ,
    handleRecentChooserError                ,


-- ** RecentManagerError #enum:RecentManagerError#

    RecentManagerError(..)                  ,
    catchRecentManagerError                 ,
    handleRecentManagerError                ,


-- ** RecentSortType #enum:RecentSortType#

    RecentSortType(..)                      ,


-- ** ReliefStyle #enum:ReliefStyle#

    ReliefStyle(..)                         ,


-- ** ResizeMode #enum:ResizeMode#

    ResizeMode(..)                          ,


-- ** ResponseType #enum:ResponseType#

    ResponseType(..)                        ,


-- ** RevealerTransitionType #enum:RevealerTransitionType#

    RevealerTransitionType(..)              ,


-- ** ScrollStep #enum:ScrollStep#

    ScrollStep(..)                          ,


-- ** ScrollType #enum:ScrollType#

    ScrollType(..)                          ,


-- ** ScrollablePolicy #enum:ScrollablePolicy#

    ScrollablePolicy(..)                    ,


-- ** SelectionMode #enum:SelectionMode#

    SelectionMode(..)                       ,


-- ** SensitivityType #enum:SensitivityType#

    SensitivityType(..)                     ,


-- ** ShadowType #enum:ShadowType#

    ShadowType(..)                          ,


-- ** ShortcutType #enum:ShortcutType#

    ShortcutType(..)                        ,


-- ** SizeGroupMode #enum:SizeGroupMode#

    SizeGroupMode(..)                       ,


-- ** SizeRequestMode #enum:SizeRequestMode#

    SizeRequestMode(..)                     ,


-- ** SortType #enum:SortType#

    SortType(..)                            ,


-- ** SpinButtonUpdatePolicy #enum:SpinButtonUpdatePolicy#

    SpinButtonUpdatePolicy(..)              ,


-- ** SpinType #enum:SpinType#

    SpinType(..)                            ,


-- ** StackTransitionType #enum:StackTransitionType#

    StackTransitionType(..)                 ,


-- ** StateType #enum:StateType#

    StateType(..)                           ,


-- ** TextBufferTargetInfo #enum:TextBufferTargetInfo#

    TextBufferTargetInfo(..)                ,


-- ** TextDirection #enum:TextDirection#

    TextDirection(..)                       ,


-- ** TextExtendSelection #enum:TextExtendSelection#

    TextExtendSelection(..)                 ,


-- ** TextViewLayer #enum:TextViewLayer#

    TextViewLayer(..)                       ,


-- ** TextWindowType #enum:TextWindowType#

    TextWindowType(..)                      ,


-- ** ToolbarSpaceStyle #enum:ToolbarSpaceStyle#

    ToolbarSpaceStyle(..)                   ,


-- ** ToolbarStyle #enum:ToolbarStyle#

    ToolbarStyle(..)                        ,


-- ** TreeViewColumnSizing #enum:TreeViewColumnSizing#

    TreeViewColumnSizing(..)                ,


-- ** TreeViewDropPosition #enum:TreeViewDropPosition#

    TreeViewDropPosition(..)                ,


-- ** TreeViewGridLines #enum:TreeViewGridLines#

    TreeViewGridLines(..)                   ,


-- ** Unit #enum:Unit#

    Unit(..)                                ,


-- ** WidgetHelpType #enum:WidgetHelpType#

    WidgetHelpType(..)                      ,


-- ** WindowPosition #enum:WindowPosition#

    WindowPosition(..)                      ,


-- ** WindowType #enum:WindowType#

    WindowType(..)                          ,


-- ** WrapMode #enum:WrapMode#

    WrapMode(..)                            ,




    ) where

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

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL


-- Enum WrapMode
-- | Describes a type of line wrapping.
data WrapMode = 
      WrapModeNone
    -- ^ do not wrap lines; just make the text area wider
    | WrapModeChar
    -- ^ wrap text, breaking lines anywhere the cursor can
    --     appear (between characters, usually - if you want to be technical,
    --     between graphemes, see 'GI.Pango.Functions.getLogAttrs')
    | WrapModeWord
    -- ^ wrap text, breaking lines in between words
    | WrapModeWordChar
    -- ^ wrap text, breaking lines in between words, or if
    --     that is not enough, also between graphemes
    | AnotherWrapMode Int
    -- ^ Catch-all for unknown values
    deriving (Int -> WrapMode -> ShowS
[WrapMode] -> ShowS
WrapMode -> String
(Int -> WrapMode -> ShowS)
-> (WrapMode -> String) -> ([WrapMode] -> ShowS) -> Show WrapMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [WrapMode] -> ShowS
$cshowList :: [WrapMode] -> ShowS
show :: WrapMode -> String
$cshow :: WrapMode -> String
showsPrec :: Int -> WrapMode -> ShowS
$cshowsPrec :: Int -> WrapMode -> ShowS
Show, WrapMode -> WrapMode -> Bool
(WrapMode -> WrapMode -> Bool)
-> (WrapMode -> WrapMode -> Bool) -> Eq WrapMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: WrapMode -> WrapMode -> Bool
$c/= :: WrapMode -> WrapMode -> Bool
== :: WrapMode -> WrapMode -> Bool
$c== :: WrapMode -> WrapMode -> Bool
Eq)

instance P.Enum WrapMode where
    fromEnum :: WrapMode -> Int
fromEnum WrapModeNone = 0
    fromEnum WrapModeChar = 1
    fromEnum WrapModeWord = 2
    fromEnum WrapModeWordChar = 3
    fromEnum (AnotherWrapMode k :: Int
k) = Int
k

    toEnum :: Int -> WrapMode
toEnum 0 = WrapMode
WrapModeNone
    toEnum 1 = WrapMode
WrapModeChar
    toEnum 2 = WrapMode
WrapModeWord
    toEnum 3 = WrapMode
WrapModeWordChar
    toEnum k :: Int
k = Int -> WrapMode
AnotherWrapMode Int
k

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

foreign import ccall "gtk_wrap_mode_get_type" c_gtk_wrap_mode_get_type :: 
    IO GType

instance BoxedEnum WrapMode where
    boxedEnumType :: WrapMode -> IO GType
boxedEnumType _ = IO GType
c_gtk_wrap_mode_get_type

-- Enum WindowType
-- | A t'GI.Gtk.Objects.Window.Window' can be one of these types. Most things you’d consider a
-- “window” should have type @/GTK_WINDOW_TOPLEVEL/@; windows with this type
-- are managed by the window manager and have a frame by default (call
-- 'GI.Gtk.Objects.Window.windowSetDecorated' to toggle the frame).  Windows with type
-- @/GTK_WINDOW_POPUP/@ are ignored by the window manager; window manager
-- keybindings won’t work on them, the window manager won’t decorate the
-- window with a frame, many GTK+ features that rely on the window
-- manager will not work (e.g. resize grips and
-- maximization\/minimization). @/GTK_WINDOW_POPUP/@ is used to implement
-- widgets such as t'GI.Gtk.Objects.Menu.Menu' or tooltips that you normally don’t think of
-- as windows per se. Nearly all windows should be @/GTK_WINDOW_TOPLEVEL/@.
-- In particular, do not use @/GTK_WINDOW_POPUP/@ just to turn off
-- the window borders; use 'GI.Gtk.Objects.Window.windowSetDecorated' for that.
data WindowType = 
      WindowTypeToplevel
    -- ^ A regular window, such as a dialog.
    | WindowTypePopup
    -- ^ A special window such as a tooltip.
    | AnotherWindowType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> WindowType -> ShowS
[WindowType] -> ShowS
WindowType -> String
(Int -> WindowType -> ShowS)
-> (WindowType -> String)
-> ([WindowType] -> ShowS)
-> Show WindowType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [WindowType] -> ShowS
$cshowList :: [WindowType] -> ShowS
show :: WindowType -> String
$cshow :: WindowType -> String
showsPrec :: Int -> WindowType -> ShowS
$cshowsPrec :: Int -> WindowType -> ShowS
Show, WindowType -> WindowType -> Bool
(WindowType -> WindowType -> Bool)
-> (WindowType -> WindowType -> Bool) -> Eq WindowType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: WindowType -> WindowType -> Bool
$c/= :: WindowType -> WindowType -> Bool
== :: WindowType -> WindowType -> Bool
$c== :: WindowType -> WindowType -> Bool
Eq)

instance P.Enum WindowType where
    fromEnum :: WindowType -> Int
fromEnum WindowTypeToplevel = 0
    fromEnum WindowTypePopup = 1
    fromEnum (AnotherWindowType k :: Int
k) = Int
k

    toEnum :: Int -> WindowType
toEnum 0 = WindowType
WindowTypeToplevel
    toEnum 1 = WindowType
WindowTypePopup
    toEnum k :: Int
k = Int -> WindowType
AnotherWindowType Int
k

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

foreign import ccall "gtk_window_type_get_type" c_gtk_window_type_get_type :: 
    IO GType

instance BoxedEnum WindowType where
    boxedEnumType :: WindowType -> IO GType
boxedEnumType _ = IO GType
c_gtk_window_type_get_type

-- Enum WindowPosition
-- | Window placement can be influenced using this enumeration. Note that
-- using @/GTK_WIN_POS_CENTER_ALWAYS/@ is almost always a bad idea.
-- It won’t necessarily work well with all window managers or on all windowing systems.
data WindowPosition = 
      WindowPositionNone
    -- ^ No influence is made on placement.
    | WindowPositionCenter
    -- ^ Windows should be placed in the center of the screen.
    | WindowPositionMouse
    -- ^ Windows should be placed at the current mouse position.
    | WindowPositionCenterAlways
    -- ^ Keep window centered as it changes size, etc.
    | WindowPositionCenterOnParent
    -- ^ Center the window on its transient
    --  parent (see 'GI.Gtk.Objects.Window.windowSetTransientFor').
    | AnotherWindowPosition Int
    -- ^ Catch-all for unknown values
    deriving (Int -> WindowPosition -> ShowS
[WindowPosition] -> ShowS
WindowPosition -> String
(Int -> WindowPosition -> ShowS)
-> (WindowPosition -> String)
-> ([WindowPosition] -> ShowS)
-> Show WindowPosition
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [WindowPosition] -> ShowS
$cshowList :: [WindowPosition] -> ShowS
show :: WindowPosition -> String
$cshow :: WindowPosition -> String
showsPrec :: Int -> WindowPosition -> ShowS
$cshowsPrec :: Int -> WindowPosition -> ShowS
Show, WindowPosition -> WindowPosition -> Bool
(WindowPosition -> WindowPosition -> Bool)
-> (WindowPosition -> WindowPosition -> Bool) -> Eq WindowPosition
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: WindowPosition -> WindowPosition -> Bool
$c/= :: WindowPosition -> WindowPosition -> Bool
== :: WindowPosition -> WindowPosition -> Bool
$c== :: WindowPosition -> WindowPosition -> Bool
Eq)

instance P.Enum WindowPosition where
    fromEnum :: WindowPosition -> Int
fromEnum WindowPositionNone = 0
    fromEnum WindowPositionCenter = 1
    fromEnum WindowPositionMouse = 2
    fromEnum WindowPositionCenterAlways = 3
    fromEnum WindowPositionCenterOnParent = 4
    fromEnum (AnotherWindowPosition k :: Int
k) = Int
k

    toEnum :: Int -> WindowPosition
toEnum 0 = WindowPosition
WindowPositionNone
    toEnum 1 = WindowPosition
WindowPositionCenter
    toEnum 2 = WindowPosition
WindowPositionMouse
    toEnum 3 = WindowPosition
WindowPositionCenterAlways
    toEnum 4 = WindowPosition
WindowPositionCenterOnParent
    toEnum k :: Int
k = Int -> WindowPosition
AnotherWindowPosition Int
k

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

foreign import ccall "gtk_window_position_get_type" c_gtk_window_position_get_type :: 
    IO GType

instance BoxedEnum WindowPosition where
    boxedEnumType :: WindowPosition -> IO GType
boxedEnumType _ = IO GType
c_gtk_window_position_get_type

-- Enum WidgetHelpType
-- | Kinds of widget-specific help. Used by the [showHelp](#signal:showHelp) signal.
data WidgetHelpType = 
      WidgetHelpTypeTooltip
    -- ^ Tooltip.
    | WidgetHelpTypeWhatsThis
    -- ^ What’s this.
    | AnotherWidgetHelpType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> WidgetHelpType -> ShowS
[WidgetHelpType] -> ShowS
WidgetHelpType -> String
(Int -> WidgetHelpType -> ShowS)
-> (WidgetHelpType -> String)
-> ([WidgetHelpType] -> ShowS)
-> Show WidgetHelpType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [WidgetHelpType] -> ShowS
$cshowList :: [WidgetHelpType] -> ShowS
show :: WidgetHelpType -> String
$cshow :: WidgetHelpType -> String
showsPrec :: Int -> WidgetHelpType -> ShowS
$cshowsPrec :: Int -> WidgetHelpType -> ShowS
Show, WidgetHelpType -> WidgetHelpType -> Bool
(WidgetHelpType -> WidgetHelpType -> Bool)
-> (WidgetHelpType -> WidgetHelpType -> Bool) -> Eq WidgetHelpType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: WidgetHelpType -> WidgetHelpType -> Bool
$c/= :: WidgetHelpType -> WidgetHelpType -> Bool
== :: WidgetHelpType -> WidgetHelpType -> Bool
$c== :: WidgetHelpType -> WidgetHelpType -> Bool
Eq)

instance P.Enum WidgetHelpType where
    fromEnum :: WidgetHelpType -> Int
fromEnum WidgetHelpTypeTooltip = 0
    fromEnum WidgetHelpTypeWhatsThis = 1
    fromEnum (AnotherWidgetHelpType k :: Int
k) = Int
k

    toEnum :: Int -> WidgetHelpType
toEnum 0 = WidgetHelpType
WidgetHelpTypeTooltip
    toEnum 1 = WidgetHelpType
WidgetHelpTypeWhatsThis
    toEnum k :: Int
k = Int -> WidgetHelpType
AnotherWidgetHelpType Int
k

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

foreign import ccall "gtk_widget_help_type_get_type" c_gtk_widget_help_type_get_type :: 
    IO GType

instance BoxedEnum WidgetHelpType where
    boxedEnumType :: WidgetHelpType -> IO GType
boxedEnumType _ = IO GType
c_gtk_widget_help_type_get_type

-- Enum Unit
-- | See also 'GI.Gtk.Objects.PrintSettings.printSettingsSetPaperWidth'.
data Unit = 
      UnitNone
    -- ^ No units.
    | UnitPoints
    -- ^ Dimensions in points.
    | UnitInch
    -- ^ Dimensions in inches.
    | UnitMm
    -- ^ Dimensions in millimeters
    | AnotherUnit Int
    -- ^ Catch-all for unknown values
    deriving (Int -> Unit -> ShowS
[Unit] -> ShowS
Unit -> String
(Int -> Unit -> ShowS)
-> (Unit -> String) -> ([Unit] -> ShowS) -> Show Unit
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Unit] -> ShowS
$cshowList :: [Unit] -> ShowS
show :: Unit -> String
$cshow :: Unit -> String
showsPrec :: Int -> Unit -> ShowS
$cshowsPrec :: Int -> Unit -> ShowS
Show, Unit -> Unit -> Bool
(Unit -> Unit -> Bool) -> (Unit -> Unit -> Bool) -> Eq Unit
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Unit -> Unit -> Bool
$c/= :: Unit -> Unit -> Bool
== :: Unit -> Unit -> Bool
$c== :: Unit -> Unit -> Bool
Eq)

instance P.Enum Unit where
    fromEnum :: Unit -> Int
fromEnum UnitNone = 0
    fromEnum UnitPoints = 1
    fromEnum UnitInch = 2
    fromEnum UnitMm = 3
    fromEnum (AnotherUnit k :: Int
k) = Int
k

    toEnum :: Int -> Unit
toEnum 0 = Unit
UnitNone
    toEnum 1 = Unit
UnitPoints
    toEnum 2 = Unit
UnitInch
    toEnum 3 = Unit
UnitMm
    toEnum k :: Int
k = Int -> Unit
AnotherUnit Int
k

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

foreign import ccall "gtk_unit_get_type" c_gtk_unit_get_type :: 
    IO GType

instance BoxedEnum Unit where
    boxedEnumType :: Unit -> IO GType
boxedEnumType _ = IO GType
c_gtk_unit_get_type

-- Enum TreeViewGridLines
-- | Used to indicate which grid lines to draw in a tree view.
data TreeViewGridLines = 
      TreeViewGridLinesNone
    -- ^ No grid lines.
    | TreeViewGridLinesHorizontal
    -- ^ Horizontal grid lines.
    | TreeViewGridLinesVertical
    -- ^ Vertical grid lines.
    | TreeViewGridLinesBoth
    -- ^ Horizontal and vertical grid lines.
    | AnotherTreeViewGridLines Int
    -- ^ Catch-all for unknown values
    deriving (Int -> TreeViewGridLines -> ShowS
[TreeViewGridLines] -> ShowS
TreeViewGridLines -> String
(Int -> TreeViewGridLines -> ShowS)
-> (TreeViewGridLines -> String)
-> ([TreeViewGridLines] -> ShowS)
-> Show TreeViewGridLines
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TreeViewGridLines] -> ShowS
$cshowList :: [TreeViewGridLines] -> ShowS
show :: TreeViewGridLines -> String
$cshow :: TreeViewGridLines -> String
showsPrec :: Int -> TreeViewGridLines -> ShowS
$cshowsPrec :: Int -> TreeViewGridLines -> ShowS
Show, TreeViewGridLines -> TreeViewGridLines -> Bool
(TreeViewGridLines -> TreeViewGridLines -> Bool)
-> (TreeViewGridLines -> TreeViewGridLines -> Bool)
-> Eq TreeViewGridLines
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TreeViewGridLines -> TreeViewGridLines -> Bool
$c/= :: TreeViewGridLines -> TreeViewGridLines -> Bool
== :: TreeViewGridLines -> TreeViewGridLines -> Bool
$c== :: TreeViewGridLines -> TreeViewGridLines -> Bool
Eq)

instance P.Enum TreeViewGridLines where
    fromEnum :: TreeViewGridLines -> Int
fromEnum TreeViewGridLinesNone = 0
    fromEnum TreeViewGridLinesHorizontal = 1
    fromEnum TreeViewGridLinesVertical = 2
    fromEnum TreeViewGridLinesBoth = 3
    fromEnum (AnotherTreeViewGridLines k :: Int
k) = Int
k

    toEnum :: Int -> TreeViewGridLines
toEnum 0 = TreeViewGridLines
TreeViewGridLinesNone
    toEnum 1 = TreeViewGridLines
TreeViewGridLinesHorizontal
    toEnum 2 = TreeViewGridLines
TreeViewGridLinesVertical
    toEnum 3 = TreeViewGridLines
TreeViewGridLinesBoth
    toEnum k :: Int
k = Int -> TreeViewGridLines
AnotherTreeViewGridLines Int
k

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

foreign import ccall "gtk_tree_view_grid_lines_get_type" c_gtk_tree_view_grid_lines_get_type :: 
    IO GType

instance BoxedEnum TreeViewGridLines where
    boxedEnumType :: TreeViewGridLines -> IO GType
boxedEnumType _ = IO GType
c_gtk_tree_view_grid_lines_get_type

-- Enum TreeViewDropPosition
-- | An enum for determining where a dropped row goes.
data TreeViewDropPosition = 
      TreeViewDropPositionBefore
    -- ^ dropped row is inserted before
    | TreeViewDropPositionAfter
    -- ^ dropped row is inserted after
    | TreeViewDropPositionIntoOrBefore
    -- ^ dropped row becomes a child or is inserted before
    | TreeViewDropPositionIntoOrAfter
    -- ^ dropped row becomes a child or is inserted after
    | AnotherTreeViewDropPosition Int
    -- ^ Catch-all for unknown values
    deriving (Int -> TreeViewDropPosition -> ShowS
[TreeViewDropPosition] -> ShowS
TreeViewDropPosition -> String
(Int -> TreeViewDropPosition -> ShowS)
-> (TreeViewDropPosition -> String)
-> ([TreeViewDropPosition] -> ShowS)
-> Show TreeViewDropPosition
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TreeViewDropPosition] -> ShowS
$cshowList :: [TreeViewDropPosition] -> ShowS
show :: TreeViewDropPosition -> String
$cshow :: TreeViewDropPosition -> String
showsPrec :: Int -> TreeViewDropPosition -> ShowS
$cshowsPrec :: Int -> TreeViewDropPosition -> ShowS
Show, TreeViewDropPosition -> TreeViewDropPosition -> Bool
(TreeViewDropPosition -> TreeViewDropPosition -> Bool)
-> (TreeViewDropPosition -> TreeViewDropPosition -> Bool)
-> Eq TreeViewDropPosition
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TreeViewDropPosition -> TreeViewDropPosition -> Bool
$c/= :: TreeViewDropPosition -> TreeViewDropPosition -> Bool
== :: TreeViewDropPosition -> TreeViewDropPosition -> Bool
$c== :: TreeViewDropPosition -> TreeViewDropPosition -> Bool
Eq)

instance P.Enum TreeViewDropPosition where
    fromEnum :: TreeViewDropPosition -> Int
fromEnum TreeViewDropPositionBefore = 0
    fromEnum TreeViewDropPositionAfter = 1
    fromEnum TreeViewDropPositionIntoOrBefore = 2
    fromEnum TreeViewDropPositionIntoOrAfter = 3
    fromEnum (AnotherTreeViewDropPosition k :: Int
k) = Int
k

    toEnum :: Int -> TreeViewDropPosition
toEnum 0 = TreeViewDropPosition
TreeViewDropPositionBefore
    toEnum 1 = TreeViewDropPosition
TreeViewDropPositionAfter
    toEnum 2 = TreeViewDropPosition
TreeViewDropPositionIntoOrBefore
    toEnum 3 = TreeViewDropPosition
TreeViewDropPositionIntoOrAfter
    toEnum k :: Int
k = Int -> TreeViewDropPosition
AnotherTreeViewDropPosition Int
k

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

foreign import ccall "gtk_tree_view_drop_position_get_type" c_gtk_tree_view_drop_position_get_type :: 
    IO GType

instance BoxedEnum TreeViewDropPosition where
    boxedEnumType :: TreeViewDropPosition -> IO GType
boxedEnumType _ = IO GType
c_gtk_tree_view_drop_position_get_type

-- Enum TreeViewColumnSizing
-- | The sizing method the column uses to determine its width.  Please note
-- that /@gTKTREEVIEWCOLUMNAUTOSIZE@/ are inefficient for large views, and
-- can make columns appear choppy.
data TreeViewColumnSizing = 
      TreeViewColumnSizingGrowOnly
    -- ^ Columns only get bigger in reaction to changes in the model
    | TreeViewColumnSizingAutosize
    -- ^ Columns resize to be the optimal size everytime the model changes.
    | TreeViewColumnSizingFixed
    -- ^ Columns are a fixed numbers of pixels wide.
    | AnotherTreeViewColumnSizing Int
    -- ^ Catch-all for unknown values
    deriving (Int -> TreeViewColumnSizing -> ShowS
[TreeViewColumnSizing] -> ShowS
TreeViewColumnSizing -> String
(Int -> TreeViewColumnSizing -> ShowS)
-> (TreeViewColumnSizing -> String)
-> ([TreeViewColumnSizing] -> ShowS)
-> Show TreeViewColumnSizing
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TreeViewColumnSizing] -> ShowS
$cshowList :: [TreeViewColumnSizing] -> ShowS
show :: TreeViewColumnSizing -> String
$cshow :: TreeViewColumnSizing -> String
showsPrec :: Int -> TreeViewColumnSizing -> ShowS
$cshowsPrec :: Int -> TreeViewColumnSizing -> ShowS
Show, TreeViewColumnSizing -> TreeViewColumnSizing -> Bool
(TreeViewColumnSizing -> TreeViewColumnSizing -> Bool)
-> (TreeViewColumnSizing -> TreeViewColumnSizing -> Bool)
-> Eq TreeViewColumnSizing
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TreeViewColumnSizing -> TreeViewColumnSizing -> Bool
$c/= :: TreeViewColumnSizing -> TreeViewColumnSizing -> Bool
== :: TreeViewColumnSizing -> TreeViewColumnSizing -> Bool
$c== :: TreeViewColumnSizing -> TreeViewColumnSizing -> Bool
Eq)

instance P.Enum TreeViewColumnSizing where
    fromEnum :: TreeViewColumnSizing -> Int
fromEnum TreeViewColumnSizingGrowOnly = 0
    fromEnum TreeViewColumnSizingAutosize = 1
    fromEnum TreeViewColumnSizingFixed = 2
    fromEnum (AnotherTreeViewColumnSizing k :: Int
k) = Int
k

    toEnum :: Int -> TreeViewColumnSizing
toEnum 0 = TreeViewColumnSizing
TreeViewColumnSizingGrowOnly
    toEnum 1 = TreeViewColumnSizing
TreeViewColumnSizingAutosize
    toEnum 2 = TreeViewColumnSizing
TreeViewColumnSizingFixed
    toEnum k :: Int
k = Int -> TreeViewColumnSizing
AnotherTreeViewColumnSizing Int
k

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

foreign import ccall "gtk_tree_view_column_sizing_get_type" c_gtk_tree_view_column_sizing_get_type :: 
    IO GType

instance BoxedEnum TreeViewColumnSizing where
    boxedEnumType :: TreeViewColumnSizing -> IO GType
boxedEnumType _ = IO GType
c_gtk_tree_view_column_sizing_get_type

-- Enum ToolbarStyle
-- | Used to customize the appearance of a t'GI.Gtk.Objects.Toolbar.Toolbar'. Note that
-- setting the toolbar style overrides the user’s preferences
-- for the default toolbar style.  Note that if the button has only
-- a label set and GTK_TOOLBAR_ICONS is used, the label will be
-- visible, and vice versa.
data ToolbarStyle = 
      ToolbarStyleIcons
    -- ^ Buttons display only icons in the toolbar.
    | ToolbarStyleText
    -- ^ Buttons display only text labels in the toolbar.
    | ToolbarStyleBoth
    -- ^ Buttons display text and icons in the toolbar.
    | ToolbarStyleBothHoriz
    -- ^ Buttons display icons and text alongside each
    --  other, rather than vertically stacked
    | AnotherToolbarStyle Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ToolbarStyle -> ShowS
[ToolbarStyle] -> ShowS
ToolbarStyle -> String
(Int -> ToolbarStyle -> ShowS)
-> (ToolbarStyle -> String)
-> ([ToolbarStyle] -> ShowS)
-> Show ToolbarStyle
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ToolbarStyle] -> ShowS
$cshowList :: [ToolbarStyle] -> ShowS
show :: ToolbarStyle -> String
$cshow :: ToolbarStyle -> String
showsPrec :: Int -> ToolbarStyle -> ShowS
$cshowsPrec :: Int -> ToolbarStyle -> ShowS
Show, ToolbarStyle -> ToolbarStyle -> Bool
(ToolbarStyle -> ToolbarStyle -> Bool)
-> (ToolbarStyle -> ToolbarStyle -> Bool) -> Eq ToolbarStyle
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ToolbarStyle -> ToolbarStyle -> Bool
$c/= :: ToolbarStyle -> ToolbarStyle -> Bool
== :: ToolbarStyle -> ToolbarStyle -> Bool
$c== :: ToolbarStyle -> ToolbarStyle -> Bool
Eq)

instance P.Enum ToolbarStyle where
    fromEnum :: ToolbarStyle -> Int
fromEnum ToolbarStyleIcons = 0
    fromEnum ToolbarStyleText = 1
    fromEnum ToolbarStyleBoth = 2
    fromEnum ToolbarStyleBothHoriz = 3
    fromEnum (AnotherToolbarStyle k :: Int
k) = Int
k

    toEnum :: Int -> ToolbarStyle
toEnum 0 = ToolbarStyle
ToolbarStyleIcons
    toEnum 1 = ToolbarStyle
ToolbarStyleText
    toEnum 2 = ToolbarStyle
ToolbarStyleBoth
    toEnum 3 = ToolbarStyle
ToolbarStyleBothHoriz
    toEnum k :: Int
k = Int -> ToolbarStyle
AnotherToolbarStyle Int
k

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

foreign import ccall "gtk_toolbar_style_get_type" c_gtk_toolbar_style_get_type :: 
    IO GType

instance BoxedEnum ToolbarStyle where
    boxedEnumType :: ToolbarStyle -> IO GType
boxedEnumType _ = IO GType
c_gtk_toolbar_style_get_type

-- Enum ToolbarSpaceStyle
{-# DEPRECATED ToolbarSpaceStyle ["(Since version 3.20)"] #-}
-- | Whether spacers are vertical lines or just blank.
data ToolbarSpaceStyle = 
      ToolbarSpaceStyleEmpty
    -- ^ Use blank spacers.
    | ToolbarSpaceStyleLine
    -- ^ Use vertical lines for spacers.
    | AnotherToolbarSpaceStyle Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ToolbarSpaceStyle -> ShowS
[ToolbarSpaceStyle] -> ShowS
ToolbarSpaceStyle -> String
(Int -> ToolbarSpaceStyle -> ShowS)
-> (ToolbarSpaceStyle -> String)
-> ([ToolbarSpaceStyle] -> ShowS)
-> Show ToolbarSpaceStyle
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ToolbarSpaceStyle] -> ShowS
$cshowList :: [ToolbarSpaceStyle] -> ShowS
show :: ToolbarSpaceStyle -> String
$cshow :: ToolbarSpaceStyle -> String
showsPrec :: Int -> ToolbarSpaceStyle -> ShowS
$cshowsPrec :: Int -> ToolbarSpaceStyle -> ShowS
Show, ToolbarSpaceStyle -> ToolbarSpaceStyle -> Bool
(ToolbarSpaceStyle -> ToolbarSpaceStyle -> Bool)
-> (ToolbarSpaceStyle -> ToolbarSpaceStyle -> Bool)
-> Eq ToolbarSpaceStyle
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ToolbarSpaceStyle -> ToolbarSpaceStyle -> Bool
$c/= :: ToolbarSpaceStyle -> ToolbarSpaceStyle -> Bool
== :: ToolbarSpaceStyle -> ToolbarSpaceStyle -> Bool
$c== :: ToolbarSpaceStyle -> ToolbarSpaceStyle -> Bool
Eq)

instance P.Enum ToolbarSpaceStyle where
    fromEnum :: ToolbarSpaceStyle -> Int
fromEnum ToolbarSpaceStyleEmpty = 0
    fromEnum ToolbarSpaceStyleLine = 1
    fromEnum (AnotherToolbarSpaceStyle k :: Int
k) = Int
k

    toEnum :: Int -> ToolbarSpaceStyle
toEnum 0 = ToolbarSpaceStyle
ToolbarSpaceStyleEmpty
    toEnum 1 = ToolbarSpaceStyle
ToolbarSpaceStyleLine
    toEnum k :: Int
k = Int -> ToolbarSpaceStyle
AnotherToolbarSpaceStyle Int
k

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

foreign import ccall "gtk_toolbar_space_style_get_type" c_gtk_toolbar_space_style_get_type :: 
    IO GType

instance BoxedEnum ToolbarSpaceStyle where
    boxedEnumType :: ToolbarSpaceStyle -> IO GType
boxedEnumType _ = IO GType
c_gtk_toolbar_space_style_get_type

-- Enum TextWindowType
-- | Used to reference the parts of t'GI.Gtk.Objects.TextView.TextView'.
data TextWindowType = 
      TextWindowTypePrivate
    -- ^ Invalid value, used as a marker
    | TextWindowTypeWidget
    -- ^ Window that floats over scrolling areas.
    | TextWindowTypeText
    -- ^ Scrollable text window.
    | TextWindowTypeLeft
    -- ^ Left side border window.
    | TextWindowTypeRight
    -- ^ Right side border window.
    | TextWindowTypeTop
    -- ^ Top border window.
    | TextWindowTypeBottom
    -- ^ Bottom border window.
    | AnotherTextWindowType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> TextWindowType -> ShowS
[TextWindowType] -> ShowS
TextWindowType -> String
(Int -> TextWindowType -> ShowS)
-> (TextWindowType -> String)
-> ([TextWindowType] -> ShowS)
-> Show TextWindowType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TextWindowType] -> ShowS
$cshowList :: [TextWindowType] -> ShowS
show :: TextWindowType -> String
$cshow :: TextWindowType -> String
showsPrec :: Int -> TextWindowType -> ShowS
$cshowsPrec :: Int -> TextWindowType -> ShowS
Show, TextWindowType -> TextWindowType -> Bool
(TextWindowType -> TextWindowType -> Bool)
-> (TextWindowType -> TextWindowType -> Bool) -> Eq TextWindowType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TextWindowType -> TextWindowType -> Bool
$c/= :: TextWindowType -> TextWindowType -> Bool
== :: TextWindowType -> TextWindowType -> Bool
$c== :: TextWindowType -> TextWindowType -> Bool
Eq)

instance P.Enum TextWindowType where
    fromEnum :: TextWindowType -> Int
fromEnum TextWindowTypePrivate = 0
    fromEnum TextWindowTypeWidget = 1
    fromEnum TextWindowTypeText = 2
    fromEnum TextWindowTypeLeft = 3
    fromEnum TextWindowTypeRight = 4
    fromEnum TextWindowTypeTop = 5
    fromEnum TextWindowTypeBottom = 6
    fromEnum (AnotherTextWindowType k :: Int
k) = Int
k

    toEnum :: Int -> TextWindowType
toEnum 0 = TextWindowType
TextWindowTypePrivate
    toEnum 1 = TextWindowType
TextWindowTypeWidget
    toEnum 2 = TextWindowType
TextWindowTypeText
    toEnum 3 = TextWindowType
TextWindowTypeLeft
    toEnum 4 = TextWindowType
TextWindowTypeRight
    toEnum 5 = TextWindowType
TextWindowTypeTop
    toEnum 6 = TextWindowType
TextWindowTypeBottom
    toEnum k :: Int
k = Int -> TextWindowType
AnotherTextWindowType Int
k

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

foreign import ccall "gtk_text_window_type_get_type" c_gtk_text_window_type_get_type :: 
    IO GType

instance BoxedEnum TextWindowType where
    boxedEnumType :: TextWindowType -> IO GType
boxedEnumType _ = IO GType
c_gtk_text_window_type_get_type

-- Enum TextViewLayer
-- | Used to reference the layers of t'GI.Gtk.Objects.TextView.TextView' for the purpose of customized
-- drawing with the [draw_layer](#signal:draw_layer) vfunc.
data TextViewLayer = 
      TextViewLayerBelow
    -- ^ Old deprecated layer, use 'GI.Gtk.Enums.TextViewLayerBelowText' instead
    | TextViewLayerAbove
    -- ^ Old deprecated layer, use 'GI.Gtk.Enums.TextViewLayerAboveText' instead
    | TextViewLayerBelowText
    -- ^ The layer rendered below the text (but above the background).  Since: 3.20
    | TextViewLayerAboveText
    -- ^ The layer rendered above the text.  Since: 3.20
    | AnotherTextViewLayer Int
    -- ^ Catch-all for unknown values
    deriving (Int -> TextViewLayer -> ShowS
[TextViewLayer] -> ShowS
TextViewLayer -> String
(Int -> TextViewLayer -> ShowS)
-> (TextViewLayer -> String)
-> ([TextViewLayer] -> ShowS)
-> Show TextViewLayer
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TextViewLayer] -> ShowS
$cshowList :: [TextViewLayer] -> ShowS
show :: TextViewLayer -> String
$cshow :: TextViewLayer -> String
showsPrec :: Int -> TextViewLayer -> ShowS
$cshowsPrec :: Int -> TextViewLayer -> ShowS
Show, TextViewLayer -> TextViewLayer -> Bool
(TextViewLayer -> TextViewLayer -> Bool)
-> (TextViewLayer -> TextViewLayer -> Bool) -> Eq TextViewLayer
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TextViewLayer -> TextViewLayer -> Bool
$c/= :: TextViewLayer -> TextViewLayer -> Bool
== :: TextViewLayer -> TextViewLayer -> Bool
$c== :: TextViewLayer -> TextViewLayer -> Bool
Eq)

instance P.Enum TextViewLayer where
    fromEnum :: TextViewLayer -> Int
fromEnum TextViewLayerBelow = 0
    fromEnum TextViewLayerAbove = 1
    fromEnum TextViewLayerBelowText = 2
    fromEnum TextViewLayerAboveText = 3
    fromEnum (AnotherTextViewLayer k :: Int
k) = Int
k

    toEnum :: Int -> TextViewLayer
toEnum 0 = TextViewLayer
TextViewLayerBelow
    toEnum 1 = TextViewLayer
TextViewLayerAbove
    toEnum 2 = TextViewLayer
TextViewLayerBelowText
    toEnum 3 = TextViewLayer
TextViewLayerAboveText
    toEnum k :: Int
k = Int -> TextViewLayer
AnotherTextViewLayer Int
k

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

foreign import ccall "gtk_text_view_layer_get_type" c_gtk_text_view_layer_get_type :: 
    IO GType

instance BoxedEnum TextViewLayer where
    boxedEnumType :: TextViewLayer -> IO GType
boxedEnumType _ = IO GType
c_gtk_text_view_layer_get_type

-- Enum TextExtendSelection
-- | Granularity types that extend the text selection. Use the
-- [extendSelection]("GI.Gtk.Objects.TextView#signal:extendSelection") signal to customize the selection.
-- 
-- /Since: 3.16/
data TextExtendSelection = 
      TextExtendSelectionWord
    -- ^ Selects the current word. It is triggered by
    --   a double-click for example.
    | TextExtendSelectionLine
    -- ^ Selects the current line. It is triggered by
    --   a triple-click for example.
    | AnotherTextExtendSelection Int
    -- ^ Catch-all for unknown values
    deriving (Int -> TextExtendSelection -> ShowS
[TextExtendSelection] -> ShowS
TextExtendSelection -> String
(Int -> TextExtendSelection -> ShowS)
-> (TextExtendSelection -> String)
-> ([TextExtendSelection] -> ShowS)
-> Show TextExtendSelection
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TextExtendSelection] -> ShowS
$cshowList :: [TextExtendSelection] -> ShowS
show :: TextExtendSelection -> String
$cshow :: TextExtendSelection -> String
showsPrec :: Int -> TextExtendSelection -> ShowS
$cshowsPrec :: Int -> TextExtendSelection -> ShowS
Show, TextExtendSelection -> TextExtendSelection -> Bool
(TextExtendSelection -> TextExtendSelection -> Bool)
-> (TextExtendSelection -> TextExtendSelection -> Bool)
-> Eq TextExtendSelection
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TextExtendSelection -> TextExtendSelection -> Bool
$c/= :: TextExtendSelection -> TextExtendSelection -> Bool
== :: TextExtendSelection -> TextExtendSelection -> Bool
$c== :: TextExtendSelection -> TextExtendSelection -> Bool
Eq)

instance P.Enum TextExtendSelection where
    fromEnum :: TextExtendSelection -> Int
fromEnum TextExtendSelectionWord = 0
    fromEnum TextExtendSelectionLine = 1
    fromEnum (AnotherTextExtendSelection k :: Int
k) = Int
k

    toEnum :: Int -> TextExtendSelection
toEnum 0 = TextExtendSelection
TextExtendSelectionWord
    toEnum 1 = TextExtendSelection
TextExtendSelectionLine
    toEnum k :: Int
k = Int -> TextExtendSelection
AnotherTextExtendSelection Int
k

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

foreign import ccall "gtk_text_extend_selection_get_type" c_gtk_text_extend_selection_get_type :: 
    IO GType

instance BoxedEnum TextExtendSelection where
    boxedEnumType :: TextExtendSelection -> IO GType
boxedEnumType _ = IO GType
c_gtk_text_extend_selection_get_type

-- Enum TextDirection
-- | Reading directions for text.
data TextDirection = 
      TextDirectionNone
    -- ^ No direction.
    | TextDirectionLtr
    -- ^ Left to right text direction.
    | TextDirectionRtl
    -- ^ Right to left text direction.
    | AnotherTextDirection Int
    -- ^ Catch-all for unknown values
    deriving (Int -> TextDirection -> ShowS
[TextDirection] -> ShowS
TextDirection -> String
(Int -> TextDirection -> ShowS)
-> (TextDirection -> String)
-> ([TextDirection] -> ShowS)
-> Show TextDirection
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TextDirection] -> ShowS
$cshowList :: [TextDirection] -> ShowS
show :: TextDirection -> String
$cshow :: TextDirection -> String
showsPrec :: Int -> TextDirection -> ShowS
$cshowsPrec :: Int -> TextDirection -> ShowS
Show, TextDirection -> TextDirection -> Bool
(TextDirection -> TextDirection -> Bool)
-> (TextDirection -> TextDirection -> Bool) -> Eq TextDirection
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TextDirection -> TextDirection -> Bool
$c/= :: TextDirection -> TextDirection -> Bool
== :: TextDirection -> TextDirection -> Bool
$c== :: TextDirection -> TextDirection -> Bool
Eq)

instance P.Enum TextDirection where
    fromEnum :: TextDirection -> Int
fromEnum TextDirectionNone = 0
    fromEnum TextDirectionLtr = 1
    fromEnum TextDirectionRtl = 2
    fromEnum (AnotherTextDirection k :: Int
k) = Int
k

    toEnum :: Int -> TextDirection
toEnum 0 = TextDirection
TextDirectionNone
    toEnum 1 = TextDirection
TextDirectionLtr
    toEnum 2 = TextDirection
TextDirectionRtl
    toEnum k :: Int
k = Int -> TextDirection
AnotherTextDirection Int
k

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

foreign import ccall "gtk_text_direction_get_type" c_gtk_text_direction_get_type :: 
    IO GType

instance BoxedEnum TextDirection where
    boxedEnumType :: TextDirection -> IO GType
boxedEnumType _ = IO GType
c_gtk_text_direction_get_type

-- Enum TextBufferTargetInfo
-- | These values are used as “info” for the targets contained in the
-- lists returned by 'GI.Gtk.Objects.TextBuffer.textBufferGetCopyTargetList' and
-- 'GI.Gtk.Objects.TextBuffer.textBufferGetPasteTargetList'.
-- 
-- The values counts down from @-1@ to avoid clashes
-- with application added drag destinations which usually start at 0.
data TextBufferTargetInfo = 
      TextBufferTargetInfoBufferContents
    -- ^ Buffer contents
    | TextBufferTargetInfoRichText
    -- ^ Rich text
    | TextBufferTargetInfoText
    -- ^ Text
    | AnotherTextBufferTargetInfo Int
    -- ^ Catch-all for unknown values
    deriving (Int -> TextBufferTargetInfo -> ShowS
[TextBufferTargetInfo] -> ShowS
TextBufferTargetInfo -> String
(Int -> TextBufferTargetInfo -> ShowS)
-> (TextBufferTargetInfo -> String)
-> ([TextBufferTargetInfo] -> ShowS)
-> Show TextBufferTargetInfo
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TextBufferTargetInfo] -> ShowS
$cshowList :: [TextBufferTargetInfo] -> ShowS
show :: TextBufferTargetInfo -> String
$cshow :: TextBufferTargetInfo -> String
showsPrec :: Int -> TextBufferTargetInfo -> ShowS
$cshowsPrec :: Int -> TextBufferTargetInfo -> ShowS
Show, TextBufferTargetInfo -> TextBufferTargetInfo -> Bool
(TextBufferTargetInfo -> TextBufferTargetInfo -> Bool)
-> (TextBufferTargetInfo -> TextBufferTargetInfo -> Bool)
-> Eq TextBufferTargetInfo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TextBufferTargetInfo -> TextBufferTargetInfo -> Bool
$c/= :: TextBufferTargetInfo -> TextBufferTargetInfo -> Bool
== :: TextBufferTargetInfo -> TextBufferTargetInfo -> Bool
$c== :: TextBufferTargetInfo -> TextBufferTargetInfo -> Bool
Eq)

instance P.Enum TextBufferTargetInfo where
    fromEnum :: TextBufferTargetInfo -> Int
fromEnum TextBufferTargetInfoBufferContents = -1
    fromEnum TextBufferTargetInfoRichText = -2
    fromEnum TextBufferTargetInfoText = -3
    fromEnum (AnotherTextBufferTargetInfo k :: Int
k) = Int
k

    toEnum :: Int -> TextBufferTargetInfo
toEnum -1 = TextBufferTargetInfo
TextBufferTargetInfoBufferContents
    toEnum -2 = TextBufferTargetInfo
TextBufferTargetInfoRichText
    toEnum -3 = TextBufferTargetInfo
TextBufferTargetInfoText
    toEnum k :: Int
k = Int -> TextBufferTargetInfo
AnotherTextBufferTargetInfo Int
k

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

foreign import ccall "gtk_text_buffer_target_info_get_type" c_gtk_text_buffer_target_info_get_type :: 
    IO GType

instance BoxedEnum TextBufferTargetInfo where
    boxedEnumType :: TextBufferTargetInfo -> IO GType
boxedEnumType _ = IO GType
c_gtk_text_buffer_target_info_get_type

-- Enum StateType
{-# DEPRECATED StateType ["(Since version 3.14)","All APIs that are using this enumeration have been deprecated","    in favor of alternatives using t'GI.Gtk.Flags.StateFlags'."] #-}
-- | This type indicates the current state of a widget; the state determines how
-- the widget is drawn. The t'GI.Gtk.Enums.StateType' enumeration is also used to
-- identify different colors in a t'GI.Gtk.Objects.Style.Style' for drawing, so states can be
-- used for subparts of a widget as well as entire widgets.
data StateType = 
      StateTypeNormal
    -- ^ State during normal operation.
    | StateTypeActive
    -- ^ State of a currently active widget, such as a depressed button.
    | StateTypePrelight
    -- ^ State indicating that the mouse pointer is over
    --                      the widget and the widget will respond to mouse clicks.
    | StateTypeSelected
    -- ^ State of a selected item, such the selected row in a list.
    | StateTypeInsensitive
    -- ^ State indicating that the widget is
    --                         unresponsive to user actions.
    | StateTypeInconsistent
    -- ^ The widget is inconsistent, such as checkbuttons
    --                          or radiobuttons that aren’t either set to 'P.True' nor 'P.False',
    --                          or buttons requiring the user attention.
    | StateTypeFocused
    -- ^ The widget has the keyboard focus.
    | AnotherStateType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> StateType -> ShowS
[StateType] -> ShowS
StateType -> String
(Int -> StateType -> ShowS)
-> (StateType -> String)
-> ([StateType] -> ShowS)
-> Show StateType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StateType] -> ShowS
$cshowList :: [StateType] -> ShowS
show :: StateType -> String
$cshow :: StateType -> String
showsPrec :: Int -> StateType -> ShowS
$cshowsPrec :: Int -> StateType -> ShowS
Show, StateType -> StateType -> Bool
(StateType -> StateType -> Bool)
-> (StateType -> StateType -> Bool) -> Eq StateType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StateType -> StateType -> Bool
$c/= :: StateType -> StateType -> Bool
== :: StateType -> StateType -> Bool
$c== :: StateType -> StateType -> Bool
Eq)

instance P.Enum StateType where
    fromEnum :: StateType -> Int
fromEnum StateTypeNormal = 0
    fromEnum StateTypeActive = 1
    fromEnum StateTypePrelight = 2
    fromEnum StateTypeSelected = 3
    fromEnum StateTypeInsensitive = 4
    fromEnum StateTypeInconsistent = 5
    fromEnum StateTypeFocused = 6
    fromEnum (AnotherStateType k :: Int
k) = Int
k

    toEnum :: Int -> StateType
toEnum 0 = StateType
StateTypeNormal
    toEnum 1 = StateType
StateTypeActive
    toEnum 2 = StateType
StateTypePrelight
    toEnum 3 = StateType
StateTypeSelected
    toEnum 4 = StateType
StateTypeInsensitive
    toEnum 5 = StateType
StateTypeInconsistent
    toEnum 6 = StateType
StateTypeFocused
    toEnum k :: Int
k = Int -> StateType
AnotherStateType Int
k

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

foreign import ccall "gtk_state_type_get_type" c_gtk_state_type_get_type :: 
    IO GType

instance BoxedEnum StateType where
    boxedEnumType :: StateType -> IO GType
boxedEnumType _ = IO GType
c_gtk_state_type_get_type

-- Enum StackTransitionType
-- | These enumeration values describe the possible transitions
-- between pages in a t'GI.Gtk.Objects.Stack.Stack' widget.
-- 
-- New values may be added to this enumeration over time.
data StackTransitionType = 
      StackTransitionTypeNone
    -- ^ No transition
    | StackTransitionTypeCrossfade
    -- ^ A cross-fade
    | StackTransitionTypeSlideRight
    -- ^ Slide from left to right
    | StackTransitionTypeSlideLeft
    -- ^ Slide from right to left
    | StackTransitionTypeSlideUp
    -- ^ Slide from bottom up
    | StackTransitionTypeSlideDown
    -- ^ Slide from top down
    | StackTransitionTypeSlideLeftRight
    -- ^ Slide from left or right according to the children order
    | StackTransitionTypeSlideUpDown
    -- ^ Slide from top down or bottom up according to the order
    | StackTransitionTypeOverUp
    -- ^ Cover the old page by sliding up. Since 3.12
    | StackTransitionTypeOverDown
    -- ^ Cover the old page by sliding down. Since: 3.12
    | StackTransitionTypeOverLeft
    -- ^ Cover the old page by sliding to the left. Since: 3.12
    | StackTransitionTypeOverRight
    -- ^ Cover the old page by sliding to the right. Since: 3.12
    | StackTransitionTypeUnderUp
    -- ^ Uncover the new page by sliding up. Since 3.12
    | StackTransitionTypeUnderDown
    -- ^ Uncover the new page by sliding down. Since: 3.12
    | StackTransitionTypeUnderLeft
    -- ^ Uncover the new page by sliding to the left. Since: 3.12
    | StackTransitionTypeUnderRight
    -- ^ Uncover the new page by sliding to the right. Since: 3.12
    | StackTransitionTypeOverUpDown
    -- ^ Cover the old page sliding up or uncover the new page sliding down, according to order. Since: 3.12
    | StackTransitionTypeOverDownUp
    -- ^ Cover the old page sliding down or uncover the new page sliding up, according to order. Since: 3.14
    | StackTransitionTypeOverLeftRight
    -- ^ Cover the old page sliding left or uncover the new page sliding right, according to order. Since: 3.14
    | StackTransitionTypeOverRightLeft
    -- ^ Cover the old page sliding right or uncover the new page sliding left, according to order. Since: 3.14
    | AnotherStackTransitionType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> StackTransitionType -> ShowS
[StackTransitionType] -> ShowS
StackTransitionType -> String
(Int -> StackTransitionType -> ShowS)
-> (StackTransitionType -> String)
-> ([StackTransitionType] -> ShowS)
-> Show StackTransitionType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StackTransitionType] -> ShowS
$cshowList :: [StackTransitionType] -> ShowS
show :: StackTransitionType -> String
$cshow :: StackTransitionType -> String
showsPrec :: Int -> StackTransitionType -> ShowS
$cshowsPrec :: Int -> StackTransitionType -> ShowS
Show, StackTransitionType -> StackTransitionType -> Bool
(StackTransitionType -> StackTransitionType -> Bool)
-> (StackTransitionType -> StackTransitionType -> Bool)
-> Eq StackTransitionType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StackTransitionType -> StackTransitionType -> Bool
$c/= :: StackTransitionType -> StackTransitionType -> Bool
== :: StackTransitionType -> StackTransitionType -> Bool
$c== :: StackTransitionType -> StackTransitionType -> Bool
Eq)

instance P.Enum StackTransitionType where
    fromEnum :: StackTransitionType -> Int
fromEnum StackTransitionTypeNone = 0
    fromEnum StackTransitionTypeCrossfade = 1
    fromEnum StackTransitionTypeSlideRight = 2
    fromEnum StackTransitionTypeSlideLeft = 3
    fromEnum StackTransitionTypeSlideUp = 4
    fromEnum StackTransitionTypeSlideDown = 5
    fromEnum StackTransitionTypeSlideLeftRight = 6
    fromEnum StackTransitionTypeSlideUpDown = 7
    fromEnum StackTransitionTypeOverUp = 8
    fromEnum StackTransitionTypeOverDown = 9
    fromEnum StackTransitionTypeOverLeft = 10
    fromEnum StackTransitionTypeOverRight = 11
    fromEnum StackTransitionTypeUnderUp = 12
    fromEnum StackTransitionTypeUnderDown = 13
    fromEnum StackTransitionTypeUnderLeft = 14
    fromEnum StackTransitionTypeUnderRight = 15
    fromEnum StackTransitionTypeOverUpDown = 16
    fromEnum StackTransitionTypeOverDownUp = 17
    fromEnum StackTransitionTypeOverLeftRight = 18
    fromEnum StackTransitionTypeOverRightLeft = 19
    fromEnum (AnotherStackTransitionType k :: Int
k) = Int
k

    toEnum :: Int -> StackTransitionType
toEnum 0 = StackTransitionType
StackTransitionTypeNone
    toEnum 1 = StackTransitionType
StackTransitionTypeCrossfade
    toEnum 2 = StackTransitionType
StackTransitionTypeSlideRight
    toEnum 3 = StackTransitionType
StackTransitionTypeSlideLeft
    toEnum 4 = StackTransitionType
StackTransitionTypeSlideUp
    toEnum 5 = StackTransitionType
StackTransitionTypeSlideDown
    toEnum 6 = StackTransitionType
StackTransitionTypeSlideLeftRight
    toEnum 7 = StackTransitionType
StackTransitionTypeSlideUpDown
    toEnum 8 = StackTransitionType
StackTransitionTypeOverUp
    toEnum 9 = StackTransitionType
StackTransitionTypeOverDown
    toEnum 10 = StackTransitionType
StackTransitionTypeOverLeft
    toEnum 11 = StackTransitionType
StackTransitionTypeOverRight
    toEnum 12 = StackTransitionType
StackTransitionTypeUnderUp
    toEnum 13 = StackTransitionType
StackTransitionTypeUnderDown
    toEnum 14 = StackTransitionType
StackTransitionTypeUnderLeft
    toEnum 15 = StackTransitionType
StackTransitionTypeUnderRight
    toEnum 16 = StackTransitionType
StackTransitionTypeOverUpDown
    toEnum 17 = StackTransitionType
StackTransitionTypeOverDownUp
    toEnum 18 = StackTransitionType
StackTransitionTypeOverLeftRight
    toEnum 19 = StackTransitionType
StackTransitionTypeOverRightLeft
    toEnum k :: Int
k = Int -> StackTransitionType
AnotherStackTransitionType Int
k

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

foreign import ccall "gtk_stack_transition_type_get_type" c_gtk_stack_transition_type_get_type :: 
    IO GType

instance BoxedEnum StackTransitionType where
    boxedEnumType :: StackTransitionType -> IO GType
boxedEnumType _ = IO GType
c_gtk_stack_transition_type_get_type

-- Enum SpinType
-- | The values of the GtkSpinType enumeration are used to specify the
-- change to make in 'GI.Gtk.Objects.SpinButton.spinButtonSpin'.
data SpinType = 
      SpinTypeStepForward
    -- ^ Increment by the adjustments step increment.
    | SpinTypeStepBackward
    -- ^ Decrement by the adjustments step increment.
    | SpinTypePageForward
    -- ^ Increment by the adjustments page increment.
    | SpinTypePageBackward
    -- ^ Decrement by the adjustments page increment.
    | SpinTypeHome
    -- ^ Go to the adjustments lower bound.
    | SpinTypeEnd
    -- ^ Go to the adjustments upper bound.
    | SpinTypeUserDefined
    -- ^ Change by a specified amount.
    | AnotherSpinType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SpinType -> ShowS
[SpinType] -> ShowS
SpinType -> String
(Int -> SpinType -> ShowS)
-> (SpinType -> String) -> ([SpinType] -> ShowS) -> Show SpinType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SpinType] -> ShowS
$cshowList :: [SpinType] -> ShowS
show :: SpinType -> String
$cshow :: SpinType -> String
showsPrec :: Int -> SpinType -> ShowS
$cshowsPrec :: Int -> SpinType -> ShowS
Show, SpinType -> SpinType -> Bool
(SpinType -> SpinType -> Bool)
-> (SpinType -> SpinType -> Bool) -> Eq SpinType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SpinType -> SpinType -> Bool
$c/= :: SpinType -> SpinType -> Bool
== :: SpinType -> SpinType -> Bool
$c== :: SpinType -> SpinType -> Bool
Eq)

instance P.Enum SpinType where
    fromEnum :: SpinType -> Int
fromEnum SpinTypeStepForward = 0
    fromEnum SpinTypeStepBackward = 1
    fromEnum SpinTypePageForward = 2
    fromEnum SpinTypePageBackward = 3
    fromEnum SpinTypeHome = 4
    fromEnum SpinTypeEnd = 5
    fromEnum SpinTypeUserDefined = 6
    fromEnum (AnotherSpinType k :: Int
k) = Int
k

    toEnum :: Int -> SpinType
toEnum 0 = SpinType
SpinTypeStepForward
    toEnum 1 = SpinType
SpinTypeStepBackward
    toEnum 2 = SpinType
SpinTypePageForward
    toEnum 3 = SpinType
SpinTypePageBackward
    toEnum 4 = SpinType
SpinTypeHome
    toEnum 5 = SpinType
SpinTypeEnd
    toEnum 6 = SpinType
SpinTypeUserDefined
    toEnum k :: Int
k = Int -> SpinType
AnotherSpinType Int
k

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

foreign import ccall "gtk_spin_type_get_type" c_gtk_spin_type_get_type :: 
    IO GType

instance BoxedEnum SpinType where
    boxedEnumType :: SpinType -> IO GType
boxedEnumType _ = IO GType
c_gtk_spin_type_get_type

-- Enum SpinButtonUpdatePolicy
-- | The spin button update policy determines whether the spin button displays
-- values even if they are outside the bounds of its adjustment.
-- See 'GI.Gtk.Objects.SpinButton.spinButtonSetUpdatePolicy'.
data SpinButtonUpdatePolicy = 
      SpinButtonUpdatePolicyAlways
    -- ^ When refreshing your t'GI.Gtk.Objects.SpinButton.SpinButton', the value is
    --     always displayed
    | SpinButtonUpdatePolicyIfValid
    -- ^ When refreshing your t'GI.Gtk.Objects.SpinButton.SpinButton', the value is
    --     only displayed if it is valid within the bounds of the spin button\'s
    --     adjustment
    | AnotherSpinButtonUpdatePolicy Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SpinButtonUpdatePolicy -> ShowS
[SpinButtonUpdatePolicy] -> ShowS
SpinButtonUpdatePolicy -> String
(Int -> SpinButtonUpdatePolicy -> ShowS)
-> (SpinButtonUpdatePolicy -> String)
-> ([SpinButtonUpdatePolicy] -> ShowS)
-> Show SpinButtonUpdatePolicy
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SpinButtonUpdatePolicy] -> ShowS
$cshowList :: [SpinButtonUpdatePolicy] -> ShowS
show :: SpinButtonUpdatePolicy -> String
$cshow :: SpinButtonUpdatePolicy -> String
showsPrec :: Int -> SpinButtonUpdatePolicy -> ShowS
$cshowsPrec :: Int -> SpinButtonUpdatePolicy -> ShowS
Show, SpinButtonUpdatePolicy -> SpinButtonUpdatePolicy -> Bool
(SpinButtonUpdatePolicy -> SpinButtonUpdatePolicy -> Bool)
-> (SpinButtonUpdatePolicy -> SpinButtonUpdatePolicy -> Bool)
-> Eq SpinButtonUpdatePolicy
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SpinButtonUpdatePolicy -> SpinButtonUpdatePolicy -> Bool
$c/= :: SpinButtonUpdatePolicy -> SpinButtonUpdatePolicy -> Bool
== :: SpinButtonUpdatePolicy -> SpinButtonUpdatePolicy -> Bool
$c== :: SpinButtonUpdatePolicy -> SpinButtonUpdatePolicy -> Bool
Eq)

instance P.Enum SpinButtonUpdatePolicy where
    fromEnum :: SpinButtonUpdatePolicy -> Int
fromEnum SpinButtonUpdatePolicyAlways = 0
    fromEnum SpinButtonUpdatePolicyIfValid = 1
    fromEnum (AnotherSpinButtonUpdatePolicy k :: Int
k) = Int
k

    toEnum :: Int -> SpinButtonUpdatePolicy
toEnum 0 = SpinButtonUpdatePolicy
SpinButtonUpdatePolicyAlways
    toEnum 1 = SpinButtonUpdatePolicy
SpinButtonUpdatePolicyIfValid
    toEnum k :: Int
k = Int -> SpinButtonUpdatePolicy
AnotherSpinButtonUpdatePolicy Int
k

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

foreign import ccall "gtk_spin_button_update_policy_get_type" c_gtk_spin_button_update_policy_get_type :: 
    IO GType

instance BoxedEnum SpinButtonUpdatePolicy where
    boxedEnumType :: SpinButtonUpdatePolicy -> IO GType
boxedEnumType _ = IO GType
c_gtk_spin_button_update_policy_get_type

-- Enum SortType
-- | Determines the direction of a sort.
data SortType = 
      SortTypeAscending
    -- ^ Sorting is in ascending order.
    | SortTypeDescending
    -- ^ Sorting is in descending order.
    | AnotherSortType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SortType -> ShowS
[SortType] -> ShowS
SortType -> String
(Int -> SortType -> ShowS)
-> (SortType -> String) -> ([SortType] -> ShowS) -> Show SortType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SortType] -> ShowS
$cshowList :: [SortType] -> ShowS
show :: SortType -> String
$cshow :: SortType -> String
showsPrec :: Int -> SortType -> ShowS
$cshowsPrec :: Int -> SortType -> ShowS
Show, SortType -> SortType -> Bool
(SortType -> SortType -> Bool)
-> (SortType -> SortType -> Bool) -> Eq SortType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SortType -> SortType -> Bool
$c/= :: SortType -> SortType -> Bool
== :: SortType -> SortType -> Bool
$c== :: SortType -> SortType -> Bool
Eq)

instance P.Enum SortType where
    fromEnum :: SortType -> Int
fromEnum SortTypeAscending = 0
    fromEnum SortTypeDescending = 1
    fromEnum (AnotherSortType k :: Int
k) = Int
k

    toEnum :: Int -> SortType
toEnum 0 = SortType
SortTypeAscending
    toEnum 1 = SortType
SortTypeDescending
    toEnum k :: Int
k = Int -> SortType
AnotherSortType Int
k

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

foreign import ccall "gtk_sort_type_get_type" c_gtk_sort_type_get_type :: 
    IO GType

instance BoxedEnum SortType where
    boxedEnumType :: SortType -> IO GType
boxedEnumType _ = IO GType
c_gtk_sort_type_get_type

-- Enum SizeRequestMode
-- | Specifies a preference for height-for-width or
-- width-for-height geometry management.
data SizeRequestMode = 
      SizeRequestModeHeightForWidth
    -- ^ Prefer height-for-width geometry management
    | SizeRequestModeWidthForHeight
    -- ^ Prefer width-for-height geometry management
    | SizeRequestModeConstantSize
    -- ^ Don’t trade height-for-width or width-for-height
    | AnotherSizeRequestMode Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SizeRequestMode -> ShowS
[SizeRequestMode] -> ShowS
SizeRequestMode -> String
(Int -> SizeRequestMode -> ShowS)
-> (SizeRequestMode -> String)
-> ([SizeRequestMode] -> ShowS)
-> Show SizeRequestMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SizeRequestMode] -> ShowS
$cshowList :: [SizeRequestMode] -> ShowS
show :: SizeRequestMode -> String
$cshow :: SizeRequestMode -> String
showsPrec :: Int -> SizeRequestMode -> ShowS
$cshowsPrec :: Int -> SizeRequestMode -> ShowS
Show, SizeRequestMode -> SizeRequestMode -> Bool
(SizeRequestMode -> SizeRequestMode -> Bool)
-> (SizeRequestMode -> SizeRequestMode -> Bool)
-> Eq SizeRequestMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SizeRequestMode -> SizeRequestMode -> Bool
$c/= :: SizeRequestMode -> SizeRequestMode -> Bool
== :: SizeRequestMode -> SizeRequestMode -> Bool
$c== :: SizeRequestMode -> SizeRequestMode -> Bool
Eq)

instance P.Enum SizeRequestMode where
    fromEnum :: SizeRequestMode -> Int
fromEnum SizeRequestModeHeightForWidth = 0
    fromEnum SizeRequestModeWidthForHeight = 1
    fromEnum SizeRequestModeConstantSize = 2
    fromEnum (AnotherSizeRequestMode k :: Int
k) = Int
k

    toEnum :: Int -> SizeRequestMode
toEnum 0 = SizeRequestMode
SizeRequestModeHeightForWidth
    toEnum 1 = SizeRequestMode
SizeRequestModeWidthForHeight
    toEnum 2 = SizeRequestMode
SizeRequestModeConstantSize
    toEnum k :: Int
k = Int -> SizeRequestMode
AnotherSizeRequestMode Int
k

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

foreign import ccall "gtk_size_request_mode_get_type" c_gtk_size_request_mode_get_type :: 
    IO GType

instance BoxedEnum SizeRequestMode where
    boxedEnumType :: SizeRequestMode -> IO GType
boxedEnumType _ = IO GType
c_gtk_size_request_mode_get_type

-- Enum SizeGroupMode
-- | The mode of the size group determines the directions in which the size
-- group affects the requested sizes of its component widgets.
data SizeGroupMode = 
      SizeGroupModeNone
    -- ^ group has no effect
    | SizeGroupModeHorizontal
    -- ^ group affects horizontal requisition
    | SizeGroupModeVertical
    -- ^ group affects vertical requisition
    | SizeGroupModeBoth
    -- ^ group affects both horizontal and vertical requisition
    | AnotherSizeGroupMode Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SizeGroupMode -> ShowS
[SizeGroupMode] -> ShowS
SizeGroupMode -> String
(Int -> SizeGroupMode -> ShowS)
-> (SizeGroupMode -> String)
-> ([SizeGroupMode] -> ShowS)
-> Show SizeGroupMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SizeGroupMode] -> ShowS
$cshowList :: [SizeGroupMode] -> ShowS
show :: SizeGroupMode -> String
$cshow :: SizeGroupMode -> String
showsPrec :: Int -> SizeGroupMode -> ShowS
$cshowsPrec :: Int -> SizeGroupMode -> ShowS
Show, SizeGroupMode -> SizeGroupMode -> Bool
(SizeGroupMode -> SizeGroupMode -> Bool)
-> (SizeGroupMode -> SizeGroupMode -> Bool) -> Eq SizeGroupMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SizeGroupMode -> SizeGroupMode -> Bool
$c/= :: SizeGroupMode -> SizeGroupMode -> Bool
== :: SizeGroupMode -> SizeGroupMode -> Bool
$c== :: SizeGroupMode -> SizeGroupMode -> Bool
Eq)

instance P.Enum SizeGroupMode where
    fromEnum :: SizeGroupMode -> Int
fromEnum SizeGroupModeNone = 0
    fromEnum SizeGroupModeHorizontal = 1
    fromEnum SizeGroupModeVertical = 2
    fromEnum SizeGroupModeBoth = 3
    fromEnum (AnotherSizeGroupMode k :: Int
k) = Int
k

    toEnum :: Int -> SizeGroupMode
toEnum 0 = SizeGroupMode
SizeGroupModeNone
    toEnum 1 = SizeGroupMode
SizeGroupModeHorizontal
    toEnum 2 = SizeGroupMode
SizeGroupModeVertical
    toEnum 3 = SizeGroupMode
SizeGroupModeBoth
    toEnum k :: Int
k = Int -> SizeGroupMode
AnotherSizeGroupMode Int
k

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

foreign import ccall "gtk_size_group_mode_get_type" c_gtk_size_group_mode_get_type :: 
    IO GType

instance BoxedEnum SizeGroupMode where
    boxedEnumType :: SizeGroupMode -> IO GType
boxedEnumType _ = IO GType
c_gtk_size_group_mode_get_type

-- Enum ShortcutType
-- | GtkShortcutType specifies the kind of shortcut that is being described.
-- More values may be added to this enumeration over time.
-- 
-- /Since: 3.20/
data ShortcutType = 
      ShortcutTypeAccelerator
    -- ^ The shortcut is a keyboard accelerator. The t'GI.Gtk.Objects.ShortcutsShortcut.ShortcutsShortcut':@/accelerator/@
    --   property will be used.
    | ShortcutTypeGesturePinch
    -- ^ The shortcut is a pinch gesture. GTK+ provides an icon and subtitle.
    | ShortcutTypeGestureStretch
    -- ^ The shortcut is a stretch gesture. GTK+ provides an icon and subtitle.
    | ShortcutTypeGestureRotateClockwise
    -- ^ The shortcut is a clockwise rotation gesture. GTK+ provides an icon and subtitle.
    | ShortcutTypeGestureRotateCounterclockwise
    -- ^ The shortcut is a counterclockwise rotation gesture. GTK+ provides an icon and subtitle.
    | ShortcutTypeGestureTwoFingerSwipeLeft
    -- ^ The shortcut is a two-finger swipe gesture. GTK+ provides an icon and subtitle.
    | ShortcutTypeGestureTwoFingerSwipeRight
    -- ^ The shortcut is a two-finger swipe gesture. GTK+ provides an icon and subtitle.
    | ShortcutTypeGesture
    -- ^ The shortcut is a gesture. The t'GI.Gtk.Objects.ShortcutsShortcut.ShortcutsShortcut':@/icon/@ property will be
    --   used.
    | AnotherShortcutType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ShortcutType -> ShowS
[ShortcutType] -> ShowS
ShortcutType -> String
(Int -> ShortcutType -> ShowS)
-> (ShortcutType -> String)
-> ([ShortcutType] -> ShowS)
-> Show ShortcutType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ShortcutType] -> ShowS
$cshowList :: [ShortcutType] -> ShowS
show :: ShortcutType -> String
$cshow :: ShortcutType -> String
showsPrec :: Int -> ShortcutType -> ShowS
$cshowsPrec :: Int -> ShortcutType -> ShowS
Show, ShortcutType -> ShortcutType -> Bool
(ShortcutType -> ShortcutType -> Bool)
-> (ShortcutType -> ShortcutType -> Bool) -> Eq ShortcutType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ShortcutType -> ShortcutType -> Bool
$c/= :: ShortcutType -> ShortcutType -> Bool
== :: ShortcutType -> ShortcutType -> Bool
$c== :: ShortcutType -> ShortcutType -> Bool
Eq)

instance P.Enum ShortcutType where
    fromEnum :: ShortcutType -> Int
fromEnum ShortcutTypeAccelerator = 0
    fromEnum ShortcutTypeGesturePinch = 1
    fromEnum ShortcutTypeGestureStretch = 2
    fromEnum ShortcutTypeGestureRotateClockwise = 3
    fromEnum ShortcutTypeGestureRotateCounterclockwise = 4
    fromEnum ShortcutTypeGestureTwoFingerSwipeLeft = 5
    fromEnum ShortcutTypeGestureTwoFingerSwipeRight = 6
    fromEnum ShortcutTypeGesture = 7
    fromEnum (AnotherShortcutType k :: Int
k) = Int
k

    toEnum :: Int -> ShortcutType
toEnum 0 = ShortcutType
ShortcutTypeAccelerator
    toEnum 1 = ShortcutType
ShortcutTypeGesturePinch
    toEnum 2 = ShortcutType
ShortcutTypeGestureStretch
    toEnum 3 = ShortcutType
ShortcutTypeGestureRotateClockwise
    toEnum 4 = ShortcutType
ShortcutTypeGestureRotateCounterclockwise
    toEnum 5 = ShortcutType
ShortcutTypeGestureTwoFingerSwipeLeft
    toEnum 6 = ShortcutType
ShortcutTypeGestureTwoFingerSwipeRight
    toEnum 7 = ShortcutType
ShortcutTypeGesture
    toEnum k :: Int
k = Int -> ShortcutType
AnotherShortcutType Int
k

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

foreign import ccall "gtk_shortcut_type_get_type" c_gtk_shortcut_type_get_type :: 
    IO GType

instance BoxedEnum ShortcutType where
    boxedEnumType :: ShortcutType -> IO GType
boxedEnumType _ = IO GType
c_gtk_shortcut_type_get_type

-- Enum ShadowType
-- | Used to change the appearance of an outline typically provided by a t'GI.Gtk.Objects.Frame.Frame'.
-- 
-- Note that many themes do not differentiate the appearance of the
-- various shadow types: Either their is no visible shadow (/@gTKSHADOWNONE@/),
-- or there is (any other value).
data ShadowType = 
      ShadowTypeNone
    -- ^ No outline.
    | ShadowTypeIn
    -- ^ The outline is bevelled inwards.
    | ShadowTypeOut
    -- ^ The outline is bevelled outwards like a button.
    | ShadowTypeEtchedIn
    -- ^ The outline has a sunken 3d appearance.
    | ShadowTypeEtchedOut
    -- ^ The outline has a raised 3d appearance.
    | AnotherShadowType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ShadowType -> ShowS
[ShadowType] -> ShowS
ShadowType -> String
(Int -> ShadowType -> ShowS)
-> (ShadowType -> String)
-> ([ShadowType] -> ShowS)
-> Show ShadowType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ShadowType] -> ShowS
$cshowList :: [ShadowType] -> ShowS
show :: ShadowType -> String
$cshow :: ShadowType -> String
showsPrec :: Int -> ShadowType -> ShowS
$cshowsPrec :: Int -> ShadowType -> ShowS
Show, ShadowType -> ShadowType -> Bool
(ShadowType -> ShadowType -> Bool)
-> (ShadowType -> ShadowType -> Bool) -> Eq ShadowType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ShadowType -> ShadowType -> Bool
$c/= :: ShadowType -> ShadowType -> Bool
== :: ShadowType -> ShadowType -> Bool
$c== :: ShadowType -> ShadowType -> Bool
Eq)

instance P.Enum ShadowType where
    fromEnum :: ShadowType -> Int
fromEnum ShadowTypeNone = 0
    fromEnum ShadowTypeIn = 1
    fromEnum ShadowTypeOut = 2
    fromEnum ShadowTypeEtchedIn = 3
    fromEnum ShadowTypeEtchedOut = 4
    fromEnum (AnotherShadowType k :: Int
k) = Int
k

    toEnum :: Int -> ShadowType
toEnum 0 = ShadowType
ShadowTypeNone
    toEnum 1 = ShadowType
ShadowTypeIn
    toEnum 2 = ShadowType
ShadowTypeOut
    toEnum 3 = ShadowType
ShadowTypeEtchedIn
    toEnum 4 = ShadowType
ShadowTypeEtchedOut
    toEnum k :: Int
k = Int -> ShadowType
AnotherShadowType Int
k

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

foreign import ccall "gtk_shadow_type_get_type" c_gtk_shadow_type_get_type :: 
    IO GType

instance BoxedEnum ShadowType where
    boxedEnumType :: ShadowType -> IO GType
boxedEnumType _ = IO GType
c_gtk_shadow_type_get_type

-- Enum SensitivityType
-- | Determines how GTK+ handles the sensitivity of stepper arrows
-- at the end of range widgets.
data SensitivityType = 
      SensitivityTypeAuto
    -- ^ The arrow is made insensitive if the
    --   thumb is at the end
    | SensitivityTypeOn
    -- ^ The arrow is always sensitive
    | SensitivityTypeOff
    -- ^ The arrow is always insensitive
    | AnotherSensitivityType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SensitivityType -> ShowS
[SensitivityType] -> ShowS
SensitivityType -> String
(Int -> SensitivityType -> ShowS)
-> (SensitivityType -> String)
-> ([SensitivityType] -> ShowS)
-> Show SensitivityType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SensitivityType] -> ShowS
$cshowList :: [SensitivityType] -> ShowS
show :: SensitivityType -> String
$cshow :: SensitivityType -> String
showsPrec :: Int -> SensitivityType -> ShowS
$cshowsPrec :: Int -> SensitivityType -> ShowS
Show, SensitivityType -> SensitivityType -> Bool
(SensitivityType -> SensitivityType -> Bool)
-> (SensitivityType -> SensitivityType -> Bool)
-> Eq SensitivityType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SensitivityType -> SensitivityType -> Bool
$c/= :: SensitivityType -> SensitivityType -> Bool
== :: SensitivityType -> SensitivityType -> Bool
$c== :: SensitivityType -> SensitivityType -> Bool
Eq)

instance P.Enum SensitivityType where
    fromEnum :: SensitivityType -> Int
fromEnum SensitivityTypeAuto = 0
    fromEnum SensitivityTypeOn = 1
    fromEnum SensitivityTypeOff = 2
    fromEnum (AnotherSensitivityType k :: Int
k) = Int
k

    toEnum :: Int -> SensitivityType
toEnum 0 = SensitivityType
SensitivityTypeAuto
    toEnum 1 = SensitivityType
SensitivityTypeOn
    toEnum 2 = SensitivityType
SensitivityTypeOff
    toEnum k :: Int
k = Int -> SensitivityType
AnotherSensitivityType Int
k

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

foreign import ccall "gtk_sensitivity_type_get_type" c_gtk_sensitivity_type_get_type :: 
    IO GType

instance BoxedEnum SensitivityType where
    boxedEnumType :: SensitivityType -> IO GType
boxedEnumType _ = IO GType
c_gtk_sensitivity_type_get_type

-- Enum SelectionMode
-- | Used to control what selections users are allowed to make.
data SelectionMode = 
      SelectionModeNone
    -- ^ No selection is possible.
    | SelectionModeSingle
    -- ^ Zero or one element may be selected.
    | SelectionModeBrowse
    -- ^ Exactly one element is selected.
    --     In some circumstances, such as initially or during a search
    --     operation, it’s possible for no element to be selected with
    --     'GI.Gtk.Enums.SelectionModeBrowse'. What is really enforced is that the user
    --     can’t deselect a currently selected element except by selecting
    --     another element.
    | SelectionModeMultiple
    -- ^ Any number of elements may be selected.
    --      The Ctrl key may be used to enlarge the selection, and Shift
    --      key to select between the focus and the child pointed to.
    --      Some widgets may also allow Click-drag to select a range of elements.
    | AnotherSelectionMode Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SelectionMode -> ShowS
[SelectionMode] -> ShowS
SelectionMode -> String
(Int -> SelectionMode -> ShowS)
-> (SelectionMode -> String)
-> ([SelectionMode] -> ShowS)
-> Show SelectionMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SelectionMode] -> ShowS
$cshowList :: [SelectionMode] -> ShowS
show :: SelectionMode -> String
$cshow :: SelectionMode -> String
showsPrec :: Int -> SelectionMode -> ShowS
$cshowsPrec :: Int -> SelectionMode -> ShowS
Show, SelectionMode -> SelectionMode -> Bool
(SelectionMode -> SelectionMode -> Bool)
-> (SelectionMode -> SelectionMode -> Bool) -> Eq SelectionMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SelectionMode -> SelectionMode -> Bool
$c/= :: SelectionMode -> SelectionMode -> Bool
== :: SelectionMode -> SelectionMode -> Bool
$c== :: SelectionMode -> SelectionMode -> Bool
Eq)

instance P.Enum SelectionMode where
    fromEnum :: SelectionMode -> Int
fromEnum SelectionModeNone = 0
    fromEnum SelectionModeSingle = 1
    fromEnum SelectionModeBrowse = 2
    fromEnum SelectionModeMultiple = 3
    fromEnum (AnotherSelectionMode k :: Int
k) = Int
k

    toEnum :: Int -> SelectionMode
toEnum 0 = SelectionMode
SelectionModeNone
    toEnum 1 = SelectionMode
SelectionModeSingle
    toEnum 2 = SelectionMode
SelectionModeBrowse
    toEnum 3 = SelectionMode
SelectionModeMultiple
    toEnum k :: Int
k = Int -> SelectionMode
AnotherSelectionMode Int
k

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

foreign import ccall "gtk_selection_mode_get_type" c_gtk_selection_mode_get_type :: 
    IO GType

instance BoxedEnum SelectionMode where
    boxedEnumType :: SelectionMode -> IO GType
boxedEnumType _ = IO GType
c_gtk_selection_mode_get_type

-- Enum ScrollablePolicy
-- | Defines the policy to be used in a scrollable widget when updating
-- the scrolled window adjustments in a given orientation.
data ScrollablePolicy = 
      ScrollablePolicyMinimum
    -- ^ Scrollable adjustments are based on the minimum size
    | ScrollablePolicyNatural
    -- ^ Scrollable adjustments are based on the natural size
    | AnotherScrollablePolicy Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ScrollablePolicy -> ShowS
[ScrollablePolicy] -> ShowS
ScrollablePolicy -> String
(Int -> ScrollablePolicy -> ShowS)
-> (ScrollablePolicy -> String)
-> ([ScrollablePolicy] -> ShowS)
-> Show ScrollablePolicy
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ScrollablePolicy] -> ShowS
$cshowList :: [ScrollablePolicy] -> ShowS
show :: ScrollablePolicy -> String
$cshow :: ScrollablePolicy -> String
showsPrec :: Int -> ScrollablePolicy -> ShowS
$cshowsPrec :: Int -> ScrollablePolicy -> ShowS
Show, ScrollablePolicy -> ScrollablePolicy -> Bool
(ScrollablePolicy -> ScrollablePolicy -> Bool)
-> (ScrollablePolicy -> ScrollablePolicy -> Bool)
-> Eq ScrollablePolicy
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ScrollablePolicy -> ScrollablePolicy -> Bool
$c/= :: ScrollablePolicy -> ScrollablePolicy -> Bool
== :: ScrollablePolicy -> ScrollablePolicy -> Bool
$c== :: ScrollablePolicy -> ScrollablePolicy -> Bool
Eq)

instance P.Enum ScrollablePolicy where
    fromEnum :: ScrollablePolicy -> Int
fromEnum ScrollablePolicyMinimum = 0
    fromEnum ScrollablePolicyNatural = 1
    fromEnum (AnotherScrollablePolicy k :: Int
k) = Int
k

    toEnum :: Int -> ScrollablePolicy
toEnum 0 = ScrollablePolicy
ScrollablePolicyMinimum
    toEnum 1 = ScrollablePolicy
ScrollablePolicyNatural
    toEnum k :: Int
k = Int -> ScrollablePolicy
AnotherScrollablePolicy Int
k

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

foreign import ccall "gtk_scrollable_policy_get_type" c_gtk_scrollable_policy_get_type :: 
    IO GType

instance BoxedEnum ScrollablePolicy where
    boxedEnumType :: ScrollablePolicy -> IO GType
boxedEnumType _ = IO GType
c_gtk_scrollable_policy_get_type

-- Enum ScrollType
-- | Scrolling types.
data ScrollType = 
      ScrollTypeNone
    -- ^ No scrolling.
    | ScrollTypeJump
    -- ^ Jump to new location.
    | ScrollTypeStepBackward
    -- ^ Step backward.
    | ScrollTypeStepForward
    -- ^ Step forward.
    | ScrollTypePageBackward
    -- ^ Page backward.
    | ScrollTypePageForward
    -- ^ Page forward.
    | ScrollTypeStepUp
    -- ^ Step up.
    | ScrollTypeStepDown
    -- ^ Step down.
    | ScrollTypePageUp
    -- ^ Page up.
    | ScrollTypePageDown
    -- ^ Page down.
    | ScrollTypeStepLeft
    -- ^ Step to the left.
    | ScrollTypeStepRight
    -- ^ Step to the right.
    | ScrollTypePageLeft
    -- ^ Page to the left.
    | ScrollTypePageRight
    -- ^ Page to the right.
    | ScrollTypeStart
    -- ^ Scroll to start.
    | ScrollTypeEnd
    -- ^ Scroll to end.
    | AnotherScrollType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ScrollType -> ShowS
[ScrollType] -> ShowS
ScrollType -> String
(Int -> ScrollType -> ShowS)
-> (ScrollType -> String)
-> ([ScrollType] -> ShowS)
-> Show ScrollType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ScrollType] -> ShowS
$cshowList :: [ScrollType] -> ShowS
show :: ScrollType -> String
$cshow :: ScrollType -> String
showsPrec :: Int -> ScrollType -> ShowS
$cshowsPrec :: Int -> ScrollType -> ShowS
Show, ScrollType -> ScrollType -> Bool
(ScrollType -> ScrollType -> Bool)
-> (ScrollType -> ScrollType -> Bool) -> Eq ScrollType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ScrollType -> ScrollType -> Bool
$c/= :: ScrollType -> ScrollType -> Bool
== :: ScrollType -> ScrollType -> Bool
$c== :: ScrollType -> ScrollType -> Bool
Eq)

instance P.Enum ScrollType where
    fromEnum :: ScrollType -> Int
fromEnum ScrollTypeNone = 0
    fromEnum ScrollTypeJump = 1
    fromEnum ScrollTypeStepBackward = 2
    fromEnum ScrollTypeStepForward = 3
    fromEnum ScrollTypePageBackward = 4
    fromEnum ScrollTypePageForward = 5
    fromEnum ScrollTypeStepUp = 6
    fromEnum ScrollTypeStepDown = 7
    fromEnum ScrollTypePageUp = 8
    fromEnum ScrollTypePageDown = 9
    fromEnum ScrollTypeStepLeft = 10
    fromEnum ScrollTypeStepRight = 11
    fromEnum ScrollTypePageLeft = 12
    fromEnum ScrollTypePageRight = 13
    fromEnum ScrollTypeStart = 14
    fromEnum ScrollTypeEnd = 15
    fromEnum (AnotherScrollType k :: Int
k) = Int
k

    toEnum :: Int -> ScrollType
toEnum 0 = ScrollType
ScrollTypeNone
    toEnum 1 = ScrollType
ScrollTypeJump
    toEnum 2 = ScrollType
ScrollTypeStepBackward
    toEnum 3 = ScrollType
ScrollTypeStepForward
    toEnum 4 = ScrollType
ScrollTypePageBackward
    toEnum 5 = ScrollType
ScrollTypePageForward
    toEnum 6 = ScrollType
ScrollTypeStepUp
    toEnum 7 = ScrollType
ScrollTypeStepDown
    toEnum 8 = ScrollType
ScrollTypePageUp
    toEnum 9 = ScrollType
ScrollTypePageDown
    toEnum 10 = ScrollType
ScrollTypeStepLeft
    toEnum 11 = ScrollType
ScrollTypeStepRight
    toEnum 12 = ScrollType
ScrollTypePageLeft
    toEnum 13 = ScrollType
ScrollTypePageRight
    toEnum 14 = ScrollType
ScrollTypeStart
    toEnum 15 = ScrollType
ScrollTypeEnd
    toEnum k :: Int
k = Int -> ScrollType
AnotherScrollType Int
k

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

foreign import ccall "gtk_scroll_type_get_type" c_gtk_scroll_type_get_type :: 
    IO GType

instance BoxedEnum ScrollType where
    boxedEnumType :: ScrollType -> IO GType
boxedEnumType _ = IO GType
c_gtk_scroll_type_get_type

-- Enum ScrollStep
-- | /No description available in the introspection data./
data ScrollStep = 
      ScrollStepSteps
    -- ^ Scroll in steps.
    | ScrollStepPages
    -- ^ Scroll by pages.
    | ScrollStepEnds
    -- ^ Scroll to ends.
    | ScrollStepHorizontalSteps
    -- ^ Scroll in horizontal steps.
    | ScrollStepHorizontalPages
    -- ^ Scroll by horizontal pages.
    | ScrollStepHorizontalEnds
    -- ^ Scroll to the horizontal ends.
    | AnotherScrollStep Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ScrollStep -> ShowS
[ScrollStep] -> ShowS
ScrollStep -> String
(Int -> ScrollStep -> ShowS)
-> (ScrollStep -> String)
-> ([ScrollStep] -> ShowS)
-> Show ScrollStep
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ScrollStep] -> ShowS
$cshowList :: [ScrollStep] -> ShowS
show :: ScrollStep -> String
$cshow :: ScrollStep -> String
showsPrec :: Int -> ScrollStep -> ShowS
$cshowsPrec :: Int -> ScrollStep -> ShowS
Show, ScrollStep -> ScrollStep -> Bool
(ScrollStep -> ScrollStep -> Bool)
-> (ScrollStep -> ScrollStep -> Bool) -> Eq ScrollStep
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ScrollStep -> ScrollStep -> Bool
$c/= :: ScrollStep -> ScrollStep -> Bool
== :: ScrollStep -> ScrollStep -> Bool
$c== :: ScrollStep -> ScrollStep -> Bool
Eq)

instance P.Enum ScrollStep where
    fromEnum :: ScrollStep -> Int
fromEnum ScrollStepSteps = 0
    fromEnum ScrollStepPages = 1
    fromEnum ScrollStepEnds = 2
    fromEnum ScrollStepHorizontalSteps = 3
    fromEnum ScrollStepHorizontalPages = 4
    fromEnum ScrollStepHorizontalEnds = 5
    fromEnum (AnotherScrollStep k :: Int
k) = Int
k

    toEnum :: Int -> ScrollStep
toEnum 0 = ScrollStep
ScrollStepSteps
    toEnum 1 = ScrollStep
ScrollStepPages
    toEnum 2 = ScrollStep
ScrollStepEnds
    toEnum 3 = ScrollStep
ScrollStepHorizontalSteps
    toEnum 4 = ScrollStep
ScrollStepHorizontalPages
    toEnum 5 = ScrollStep
ScrollStepHorizontalEnds
    toEnum k :: Int
k = Int -> ScrollStep
AnotherScrollStep Int
k

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

foreign import ccall "gtk_scroll_step_get_type" c_gtk_scroll_step_get_type :: 
    IO GType

instance BoxedEnum ScrollStep where
    boxedEnumType :: ScrollStep -> IO GType
boxedEnumType _ = IO GType
c_gtk_scroll_step_get_type

-- Enum RevealerTransitionType
-- | These enumeration values describe the possible transitions
-- when the child of a t'GI.Gtk.Objects.Revealer.Revealer' widget is shown or hidden.
data RevealerTransitionType = 
      RevealerTransitionTypeNone
    -- ^ No transition
    | RevealerTransitionTypeCrossfade
    -- ^ Fade in
    | RevealerTransitionTypeSlideRight
    -- ^ Slide in from the left
    | RevealerTransitionTypeSlideLeft
    -- ^ Slide in from the right
    | RevealerTransitionTypeSlideUp
    -- ^ Slide in from the bottom
    | RevealerTransitionTypeSlideDown
    -- ^ Slide in from the top
    | AnotherRevealerTransitionType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> RevealerTransitionType -> ShowS
[RevealerTransitionType] -> ShowS
RevealerTransitionType -> String
(Int -> RevealerTransitionType -> ShowS)
-> (RevealerTransitionType -> String)
-> ([RevealerTransitionType] -> ShowS)
-> Show RevealerTransitionType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RevealerTransitionType] -> ShowS
$cshowList :: [RevealerTransitionType] -> ShowS
show :: RevealerTransitionType -> String
$cshow :: RevealerTransitionType -> String
showsPrec :: Int -> RevealerTransitionType -> ShowS
$cshowsPrec :: Int -> RevealerTransitionType -> ShowS
Show, RevealerTransitionType -> RevealerTransitionType -> Bool
(RevealerTransitionType -> RevealerTransitionType -> Bool)
-> (RevealerTransitionType -> RevealerTransitionType -> Bool)
-> Eq RevealerTransitionType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RevealerTransitionType -> RevealerTransitionType -> Bool
$c/= :: RevealerTransitionType -> RevealerTransitionType -> Bool
== :: RevealerTransitionType -> RevealerTransitionType -> Bool
$c== :: RevealerTransitionType -> RevealerTransitionType -> Bool
Eq)

instance P.Enum RevealerTransitionType where
    fromEnum :: RevealerTransitionType -> Int
fromEnum RevealerTransitionTypeNone = 0
    fromEnum RevealerTransitionTypeCrossfade = 1
    fromEnum RevealerTransitionTypeSlideRight = 2
    fromEnum RevealerTransitionTypeSlideLeft = 3
    fromEnum RevealerTransitionTypeSlideUp = 4
    fromEnum RevealerTransitionTypeSlideDown = 5
    fromEnum (AnotherRevealerTransitionType k :: Int
k) = Int
k

    toEnum :: Int -> RevealerTransitionType
toEnum 0 = RevealerTransitionType
RevealerTransitionTypeNone
    toEnum 1 = RevealerTransitionType
RevealerTransitionTypeCrossfade
    toEnum 2 = RevealerTransitionType
RevealerTransitionTypeSlideRight
    toEnum 3 = RevealerTransitionType
RevealerTransitionTypeSlideLeft
    toEnum 4 = RevealerTransitionType
RevealerTransitionTypeSlideUp
    toEnum 5 = RevealerTransitionType
RevealerTransitionTypeSlideDown
    toEnum k :: Int
k = Int -> RevealerTransitionType
AnotherRevealerTransitionType Int
k

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

foreign import ccall "gtk_revealer_transition_type_get_type" c_gtk_revealer_transition_type_get_type :: 
    IO GType

instance BoxedEnum RevealerTransitionType where
    boxedEnumType :: RevealerTransitionType -> IO GType
boxedEnumType _ = IO GType
c_gtk_revealer_transition_type_get_type

-- Enum ResponseType
-- | Predefined values for use as response ids in 'GI.Gtk.Objects.Dialog.dialogAddButton'.
-- All predefined values are negative; GTK+ leaves values of 0 or greater for
-- application-defined response ids.
data ResponseType = 
      ResponseTypeNone
    -- ^ Returned if an action widget has no response id,
    --     or if the dialog gets programmatically hidden or destroyed
    | ResponseTypeReject
    -- ^ Generic response id, not used by GTK+ dialogs
    | ResponseTypeAccept
    -- ^ Generic response id, not used by GTK+ dialogs
    | ResponseTypeDeleteEvent
    -- ^ Returned if the dialog is deleted
    | ResponseTypeOk
    -- ^ Returned by OK buttons in GTK+ dialogs
    | ResponseTypeCancel
    -- ^ Returned by Cancel buttons in GTK+ dialogs
    | ResponseTypeClose
    -- ^ Returned by Close buttons in GTK+ dialogs
    | ResponseTypeYes
    -- ^ Returned by Yes buttons in GTK+ dialogs
    | ResponseTypeNo
    -- ^ Returned by No buttons in GTK+ dialogs
    | ResponseTypeApply
    -- ^ Returned by Apply buttons in GTK+ dialogs
    | ResponseTypeHelp
    -- ^ Returned by Help buttons in GTK+ dialogs
    | AnotherResponseType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ResponseType -> ShowS
[ResponseType] -> ShowS
ResponseType -> String
(Int -> ResponseType -> ShowS)
-> (ResponseType -> String)
-> ([ResponseType] -> ShowS)
-> Show ResponseType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ResponseType] -> ShowS
$cshowList :: [ResponseType] -> ShowS
show :: ResponseType -> String
$cshow :: ResponseType -> String
showsPrec :: Int -> ResponseType -> ShowS
$cshowsPrec :: Int -> ResponseType -> ShowS
Show, ResponseType -> ResponseType -> Bool
(ResponseType -> ResponseType -> Bool)
-> (ResponseType -> ResponseType -> Bool) -> Eq ResponseType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ResponseType -> ResponseType -> Bool
$c/= :: ResponseType -> ResponseType -> Bool
== :: ResponseType -> ResponseType -> Bool
$c== :: ResponseType -> ResponseType -> Bool
Eq)

instance P.Enum ResponseType where
    fromEnum :: ResponseType -> Int
fromEnum ResponseTypeNone = -1
    fromEnum ResponseTypeReject = -2
    fromEnum ResponseTypeAccept = -3
    fromEnum ResponseTypeDeleteEvent = -4
    fromEnum ResponseTypeOk = -5
    fromEnum ResponseTypeCancel = -6
    fromEnum ResponseTypeClose = -7
    fromEnum ResponseTypeYes = -8
    fromEnum ResponseTypeNo = -9
    fromEnum ResponseTypeApply = -10
    fromEnum ResponseTypeHelp = -11
    fromEnum (AnotherResponseType k :: Int
k) = Int
k

    toEnum :: Int -> ResponseType
toEnum -1 = ResponseType
ResponseTypeNone
    toEnum -2 = ResponseType
ResponseTypeReject
    toEnum -3 = ResponseType
ResponseTypeAccept
    toEnum -4 = ResponseType
ResponseTypeDeleteEvent
    toEnum -5 = ResponseType
ResponseTypeOk
    toEnum -6 = ResponseType
ResponseTypeCancel
    toEnum -7 = ResponseType
ResponseTypeClose
    toEnum -8 = ResponseType
ResponseTypeYes
    toEnum -9 = ResponseType
ResponseTypeNo
    toEnum -10 = ResponseType
ResponseTypeApply
    toEnum -11 = ResponseType
ResponseTypeHelp
    toEnum k :: Int
k = Int -> ResponseType
AnotherResponseType Int
k

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

foreign import ccall "gtk_response_type_get_type" c_gtk_response_type_get_type :: 
    IO GType

instance BoxedEnum ResponseType where
    boxedEnumType :: ResponseType -> IO GType
boxedEnumType _ = IO GType
c_gtk_response_type_get_type

-- Enum ResizeMode
-- | /No description available in the introspection data./
data ResizeMode = 
      ResizeModeParent
    -- ^ Pass resize request to the parent
    | ResizeModeQueue
    -- ^ Queue resizes on this widget
    | ResizeModeImmediate
    -- ^ Resize immediately. Deprecated.
    | AnotherResizeMode Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ResizeMode -> ShowS
[ResizeMode] -> ShowS
ResizeMode -> String
(Int -> ResizeMode -> ShowS)
-> (ResizeMode -> String)
-> ([ResizeMode] -> ShowS)
-> Show ResizeMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ResizeMode] -> ShowS
$cshowList :: [ResizeMode] -> ShowS
show :: ResizeMode -> String
$cshow :: ResizeMode -> String
showsPrec :: Int -> ResizeMode -> ShowS
$cshowsPrec :: Int -> ResizeMode -> ShowS
Show, ResizeMode -> ResizeMode -> Bool
(ResizeMode -> ResizeMode -> Bool)
-> (ResizeMode -> ResizeMode -> Bool) -> Eq ResizeMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ResizeMode -> ResizeMode -> Bool
$c/= :: ResizeMode -> ResizeMode -> Bool
== :: ResizeMode -> ResizeMode -> Bool
$c== :: ResizeMode -> ResizeMode -> Bool
Eq)

instance P.Enum ResizeMode where
    fromEnum :: ResizeMode -> Int
fromEnum ResizeModeParent = 0
    fromEnum ResizeModeQueue = 1
    fromEnum ResizeModeImmediate = 2
    fromEnum (AnotherResizeMode k :: Int
k) = Int
k

    toEnum :: Int -> ResizeMode
toEnum 0 = ResizeMode
ResizeModeParent
    toEnum 1 = ResizeMode
ResizeModeQueue
    toEnum 2 = ResizeMode
ResizeModeImmediate
    toEnum k :: Int
k = Int -> ResizeMode
AnotherResizeMode Int
k

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

foreign import ccall "gtk_resize_mode_get_type" c_gtk_resize_mode_get_type :: 
    IO GType

instance BoxedEnum ResizeMode where
    boxedEnumType :: ResizeMode -> IO GType
boxedEnumType _ = IO GType
c_gtk_resize_mode_get_type

-- Enum ReliefStyle
-- | Indicated the relief to be drawn around a t'GI.Gtk.Objects.Button.Button'.
data ReliefStyle = 
      ReliefStyleNormal
    -- ^ Draw a normal relief.
    | ReliefStyleHalf
    -- ^ A half relief. Deprecated in 3.14, does the same as /@gTKRELIEFNORMAL@/
    | ReliefStyleNone
    -- ^ No relief.
    | AnotherReliefStyle Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ReliefStyle -> ShowS
[ReliefStyle] -> ShowS
ReliefStyle -> String
(Int -> ReliefStyle -> ShowS)
-> (ReliefStyle -> String)
-> ([ReliefStyle] -> ShowS)
-> Show ReliefStyle
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ReliefStyle] -> ShowS
$cshowList :: [ReliefStyle] -> ShowS
show :: ReliefStyle -> String
$cshow :: ReliefStyle -> String
showsPrec :: Int -> ReliefStyle -> ShowS
$cshowsPrec :: Int -> ReliefStyle -> ShowS
Show, ReliefStyle -> ReliefStyle -> Bool
(ReliefStyle -> ReliefStyle -> Bool)
-> (ReliefStyle -> ReliefStyle -> Bool) -> Eq ReliefStyle
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ReliefStyle -> ReliefStyle -> Bool
$c/= :: ReliefStyle -> ReliefStyle -> Bool
== :: ReliefStyle -> ReliefStyle -> Bool
$c== :: ReliefStyle -> ReliefStyle -> Bool
Eq)

instance P.Enum ReliefStyle where
    fromEnum :: ReliefStyle -> Int
fromEnum ReliefStyleNormal = 0
    fromEnum ReliefStyleHalf = 1
    fromEnum ReliefStyleNone = 2
    fromEnum (AnotherReliefStyle k :: Int
k) = Int
k

    toEnum :: Int -> ReliefStyle
toEnum 0 = ReliefStyle
ReliefStyleNormal
    toEnum 1 = ReliefStyle
ReliefStyleHalf
    toEnum 2 = ReliefStyle
ReliefStyleNone
    toEnum k :: Int
k = Int -> ReliefStyle
AnotherReliefStyle Int
k

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

foreign import ccall "gtk_relief_style_get_type" c_gtk_relief_style_get_type :: 
    IO GType

instance BoxedEnum ReliefStyle where
    boxedEnumType :: ReliefStyle -> IO GType
boxedEnumType _ = IO GType
c_gtk_relief_style_get_type

-- Enum RecentSortType
-- | Used to specify the sorting method to be applyed to the recently
-- used resource list.
-- 
-- /Since: 2.10/
data RecentSortType = 
      RecentSortTypeNone
    -- ^ Do not sort the returned list of recently used
    --   resources.
    | RecentSortTypeMru
    -- ^ Sort the returned list with the most recently used
    --   items first.
    | RecentSortTypeLru
    -- ^ Sort the returned list with the least recently used
    --   items first.
    | RecentSortTypeCustom
    -- ^ Sort the returned list using a custom sorting
    --   function passed using 'GI.Gtk.Interfaces.RecentChooser.recentChooserSetSortFunc'.
    | AnotherRecentSortType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> RecentSortType -> ShowS
[RecentSortType] -> ShowS
RecentSortType -> String
(Int -> RecentSortType -> ShowS)
-> (RecentSortType -> String)
-> ([RecentSortType] -> ShowS)
-> Show RecentSortType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RecentSortType] -> ShowS
$cshowList :: [RecentSortType] -> ShowS
show :: RecentSortType -> String
$cshow :: RecentSortType -> String
showsPrec :: Int -> RecentSortType -> ShowS
$cshowsPrec :: Int -> RecentSortType -> ShowS
Show, RecentSortType -> RecentSortType -> Bool
(RecentSortType -> RecentSortType -> Bool)
-> (RecentSortType -> RecentSortType -> Bool) -> Eq RecentSortType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RecentSortType -> RecentSortType -> Bool
$c/= :: RecentSortType -> RecentSortType -> Bool
== :: RecentSortType -> RecentSortType -> Bool
$c== :: RecentSortType -> RecentSortType -> Bool
Eq)

instance P.Enum RecentSortType where
    fromEnum :: RecentSortType -> Int
fromEnum RecentSortTypeNone = 0
    fromEnum RecentSortTypeMru = 1
    fromEnum RecentSortTypeLru = 2
    fromEnum RecentSortTypeCustom = 3
    fromEnum (AnotherRecentSortType k :: Int
k) = Int
k

    toEnum :: Int -> RecentSortType
toEnum 0 = RecentSortType
RecentSortTypeNone
    toEnum 1 = RecentSortType
RecentSortTypeMru
    toEnum 2 = RecentSortType
RecentSortTypeLru
    toEnum 3 = RecentSortType
RecentSortTypeCustom
    toEnum k :: Int
k = Int -> RecentSortType
AnotherRecentSortType Int
k

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

foreign import ccall "gtk_recent_sort_type_get_type" c_gtk_recent_sort_type_get_type :: 
    IO GType

instance BoxedEnum RecentSortType where
    boxedEnumType :: RecentSortType -> IO GType
boxedEnumType _ = IO GType
c_gtk_recent_sort_type_get_type

-- Enum RecentManagerError
-- | Error codes for t'GI.Gtk.Objects.RecentManager.RecentManager' operations
-- 
-- /Since: 2.10/
data RecentManagerError = 
      RecentManagerErrorNotFound
    -- ^ the URI specified does not exists in
    --   the recently used resources list.
    | RecentManagerErrorInvalidUri
    -- ^ the URI specified is not valid.
    | RecentManagerErrorInvalidEncoding
    -- ^ the supplied string is not
    --   UTF-8 encoded.
    | RecentManagerErrorNotRegistered
    -- ^ no application has registered
    --   the specified item.
    | RecentManagerErrorRead
    -- ^ failure while reading the recently used
    --   resources file.
    | RecentManagerErrorWrite
    -- ^ failure while writing the recently used
    --   resources file.
    | RecentManagerErrorUnknown
    -- ^ unspecified error.
    | AnotherRecentManagerError Int
    -- ^ Catch-all for unknown values
    deriving (Int -> RecentManagerError -> ShowS
[RecentManagerError] -> ShowS
RecentManagerError -> String
(Int -> RecentManagerError -> ShowS)
-> (RecentManagerError -> String)
-> ([RecentManagerError] -> ShowS)
-> Show RecentManagerError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RecentManagerError] -> ShowS
$cshowList :: [RecentManagerError] -> ShowS
show :: RecentManagerError -> String
$cshow :: RecentManagerError -> String
showsPrec :: Int -> RecentManagerError -> ShowS
$cshowsPrec :: Int -> RecentManagerError -> ShowS
Show, RecentManagerError -> RecentManagerError -> Bool
(RecentManagerError -> RecentManagerError -> Bool)
-> (RecentManagerError -> RecentManagerError -> Bool)
-> Eq RecentManagerError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RecentManagerError -> RecentManagerError -> Bool
$c/= :: RecentManagerError -> RecentManagerError -> Bool
== :: RecentManagerError -> RecentManagerError -> Bool
$c== :: RecentManagerError -> RecentManagerError -> Bool
Eq)

instance P.Enum RecentManagerError where
    fromEnum :: RecentManagerError -> Int
fromEnum RecentManagerErrorNotFound = 0
    fromEnum RecentManagerErrorInvalidUri = 1
    fromEnum RecentManagerErrorInvalidEncoding = 2
    fromEnum RecentManagerErrorNotRegistered = 3
    fromEnum RecentManagerErrorRead = 4
    fromEnum RecentManagerErrorWrite = 5
    fromEnum RecentManagerErrorUnknown = 6
    fromEnum (AnotherRecentManagerError k :: Int
k) = Int
k

    toEnum :: Int -> RecentManagerError
toEnum 0 = RecentManagerError
RecentManagerErrorNotFound
    toEnum 1 = RecentManagerError
RecentManagerErrorInvalidUri
    toEnum 2 = RecentManagerError
RecentManagerErrorInvalidEncoding
    toEnum 3 = RecentManagerError
RecentManagerErrorNotRegistered
    toEnum 4 = RecentManagerError
RecentManagerErrorRead
    toEnum 5 = RecentManagerError
RecentManagerErrorWrite
    toEnum 6 = RecentManagerError
RecentManagerErrorUnknown
    toEnum k :: Int
k = Int -> RecentManagerError
AnotherRecentManagerError Int
k

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

instance GErrorClass RecentManagerError where
    gerrorClassDomain :: RecentManagerError -> Text
gerrorClassDomain _ = "gtk-recent-manager-error-quark"

-- | Catch exceptions of type `RecentManagerError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
catchRecentManagerError ::
    IO a ->
    (RecentManagerError -> GErrorMessage -> IO a) ->
    IO a
catchRecentManagerError :: IO a -> (RecentManagerError -> Text -> IO a) -> IO a
catchRecentManagerError = IO a -> (RecentManagerError -> Text -> IO a) -> IO a
forall err a.
GErrorClass err =>
IO a -> (err -> Text -> IO a) -> IO a
catchGErrorJustDomain

-- | Handle exceptions of type `RecentManagerError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
handleRecentManagerError ::
    (RecentManagerError -> GErrorMessage -> IO a) ->
    IO a ->
    IO a
handleRecentManagerError :: (RecentManagerError -> Text -> IO a) -> IO a -> IO a
handleRecentManagerError = (RecentManagerError -> Text -> IO a) -> IO a -> IO a
forall err a.
GErrorClass err =>
(err -> Text -> IO a) -> IO a -> IO a
handleGErrorJustDomain

foreign import ccall "gtk_recent_manager_error_get_type" c_gtk_recent_manager_error_get_type :: 
    IO GType

instance BoxedEnum RecentManagerError where
    boxedEnumType :: RecentManagerError -> IO GType
boxedEnumType _ = IO GType
c_gtk_recent_manager_error_get_type

-- Enum RecentChooserError
-- | These identify the various errors that can occur while calling
-- t'GI.Gtk.Interfaces.RecentChooser.RecentChooser' functions.
-- 
-- /Since: 2.10/
data RecentChooserError = 
      RecentChooserErrorNotFound
    -- ^ Indicates that a file does not exist
    | RecentChooserErrorInvalidUri
    -- ^ Indicates a malformed URI
    | AnotherRecentChooserError Int
    -- ^ Catch-all for unknown values
    deriving (Int -> RecentChooserError -> ShowS
[RecentChooserError] -> ShowS
RecentChooserError -> String
(Int -> RecentChooserError -> ShowS)
-> (RecentChooserError -> String)
-> ([RecentChooserError] -> ShowS)
-> Show RecentChooserError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RecentChooserError] -> ShowS
$cshowList :: [RecentChooserError] -> ShowS
show :: RecentChooserError -> String
$cshow :: RecentChooserError -> String
showsPrec :: Int -> RecentChooserError -> ShowS
$cshowsPrec :: Int -> RecentChooserError -> ShowS
Show, RecentChooserError -> RecentChooserError -> Bool
(RecentChooserError -> RecentChooserError -> Bool)
-> (RecentChooserError -> RecentChooserError -> Bool)
-> Eq RecentChooserError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RecentChooserError -> RecentChooserError -> Bool
$c/= :: RecentChooserError -> RecentChooserError -> Bool
== :: RecentChooserError -> RecentChooserError -> Bool
$c== :: RecentChooserError -> RecentChooserError -> Bool
Eq)

instance P.Enum RecentChooserError where
    fromEnum :: RecentChooserError -> Int
fromEnum RecentChooserErrorNotFound = 0
    fromEnum RecentChooserErrorInvalidUri = 1
    fromEnum (AnotherRecentChooserError k :: Int
k) = Int
k

    toEnum :: Int -> RecentChooserError
toEnum 0 = RecentChooserError
RecentChooserErrorNotFound
    toEnum 1 = RecentChooserError
RecentChooserErrorInvalidUri
    toEnum k :: Int
k = Int -> RecentChooserError
AnotherRecentChooserError Int
k

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

instance GErrorClass RecentChooserError where
    gerrorClassDomain :: RecentChooserError -> Text
gerrorClassDomain _ = "gtk-recent-chooser-error-quark"

-- | Catch exceptions of type `RecentChooserError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
catchRecentChooserError ::
    IO a ->
    (RecentChooserError -> GErrorMessage -> IO a) ->
    IO a
catchRecentChooserError :: IO a -> (RecentChooserError -> Text -> IO a) -> IO a
catchRecentChooserError = IO a -> (RecentChooserError -> Text -> IO a) -> IO a
forall err a.
GErrorClass err =>
IO a -> (err -> Text -> IO a) -> IO a
catchGErrorJustDomain

-- | Handle exceptions of type `RecentChooserError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
handleRecentChooserError ::
    (RecentChooserError -> GErrorMessage -> IO a) ->
    IO a ->
    IO a
handleRecentChooserError :: (RecentChooserError -> Text -> IO a) -> IO a -> IO a
handleRecentChooserError = (RecentChooserError -> Text -> IO a) -> IO a -> IO a
forall err a.
GErrorClass err =>
(err -> Text -> IO a) -> IO a -> IO a
handleGErrorJustDomain

foreign import ccall "gtk_recent_chooser_error_get_type" c_gtk_recent_chooser_error_get_type :: 
    IO GType

instance BoxedEnum RecentChooserError where
    boxedEnumType :: RecentChooserError -> IO GType
boxedEnumType _ = IO GType
c_gtk_recent_chooser_error_get_type

-- Enum RcTokenType
{-# DEPRECATED RcTokenType ["(Since version 3.0)","Use t'GI.Gtk.Objects.CssProvider.CssProvider' instead."] #-}
-- | The t'GI.Gtk.Enums.RcTokenType' enumeration represents the tokens
-- in the RC file. It is exposed so that theme engines
-- can reuse these tokens when parsing the theme-engine
-- specific portions of a RC file.
data RcTokenType = 
      RcTokenTypeInvalid
    -- ^ Deprecated
    | RcTokenTypeInclude
    -- ^ Deprecated
    | RcTokenTypeNormal
    -- ^ Deprecated
    | RcTokenTypeActive
    -- ^ Deprecated
    | RcTokenTypePrelight
    -- ^ Deprecated
    | RcTokenTypeSelected
    -- ^ Deprecated
    | RcTokenTypeInsensitive
    -- ^ Deprecated
    | RcTokenTypeFg
    -- ^ Deprecated
    | RcTokenTypeBg
    -- ^ Deprecated
    | RcTokenTypeText
    -- ^ Deprecated
    | RcTokenTypeBase
    -- ^ Deprecated
    | RcTokenTypeXthickness
    -- ^ Deprecated
    | RcTokenTypeYthickness
    -- ^ Deprecated
    | RcTokenTypeFont
    -- ^ Deprecated
    | RcTokenTypeFontset
    -- ^ Deprecated
    | RcTokenTypeFontName
    -- ^ Deprecated
    | RcTokenTypeBgPixmap
    -- ^ Deprecated
    | RcTokenTypePixmapPath
    -- ^ Deprecated
    | RcTokenTypeStyle
    -- ^ Deprecated
    | RcTokenTypeBinding
    -- ^ Deprecated
    | RcTokenTypeBind
    -- ^ Deprecated
    | RcTokenTypeWidget
    -- ^ Deprecated
    | RcTokenTypeWidgetClass
    -- ^ Deprecated
    | RcTokenTypeClass
    -- ^ Deprecated
    | RcTokenTypeLowest
    -- ^ Deprecated
    | RcTokenTypeGtk
    -- ^ Deprecated
    | RcTokenTypeApplication
    -- ^ Deprecated
    | RcTokenTypeTheme
    -- ^ Deprecated
    | RcTokenTypeRc
    -- ^ Deprecated
    | RcTokenTypeHighest
    -- ^ Deprecated
    | RcTokenTypeEngine
    -- ^ Deprecated
    | RcTokenTypeModulePath
    -- ^ Deprecated
    | RcTokenTypeImModulePath
    -- ^ Deprecated
    | RcTokenTypeImModuleFile
    -- ^ Deprecated
    | RcTokenTypeStock
    -- ^ Deprecated
    | RcTokenTypeLtr
    -- ^ Deprecated
    | RcTokenTypeRtl
    -- ^ Deprecated
    | RcTokenTypeColor
    -- ^ Deprecated
    | RcTokenTypeUnbind
    -- ^ Deprecated
    | RcTokenTypeLast
    -- ^ Deprecated
    | AnotherRcTokenType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> RcTokenType -> ShowS
[RcTokenType] -> ShowS
RcTokenType -> String
(Int -> RcTokenType -> ShowS)
-> (RcTokenType -> String)
-> ([RcTokenType] -> ShowS)
-> Show RcTokenType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RcTokenType] -> ShowS
$cshowList :: [RcTokenType] -> ShowS
show :: RcTokenType -> String
$cshow :: RcTokenType -> String
showsPrec :: Int -> RcTokenType -> ShowS
$cshowsPrec :: Int -> RcTokenType -> ShowS
Show, RcTokenType -> RcTokenType -> Bool
(RcTokenType -> RcTokenType -> Bool)
-> (RcTokenType -> RcTokenType -> Bool) -> Eq RcTokenType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RcTokenType -> RcTokenType -> Bool
$c/= :: RcTokenType -> RcTokenType -> Bool
== :: RcTokenType -> RcTokenType -> Bool
$c== :: RcTokenType -> RcTokenType -> Bool
Eq)

instance P.Enum RcTokenType where
    fromEnum :: RcTokenType -> Int
fromEnum RcTokenTypeInvalid = 270
    fromEnum RcTokenTypeInclude = 271
    fromEnum RcTokenTypeNormal = 272
    fromEnum RcTokenTypeActive = 273
    fromEnum RcTokenTypePrelight = 274
    fromEnum RcTokenTypeSelected = 275
    fromEnum RcTokenTypeInsensitive = 276
    fromEnum RcTokenTypeFg = 277
    fromEnum RcTokenTypeBg = 278
    fromEnum RcTokenTypeText = 279
    fromEnum RcTokenTypeBase = 280
    fromEnum RcTokenTypeXthickness = 281
    fromEnum RcTokenTypeYthickness = 282
    fromEnum RcTokenTypeFont = 283
    fromEnum RcTokenTypeFontset = 284
    fromEnum RcTokenTypeFontName = 285
    fromEnum RcTokenTypeBgPixmap = 286
    fromEnum RcTokenTypePixmapPath = 287
    fromEnum RcTokenTypeStyle = 288
    fromEnum RcTokenTypeBinding = 289
    fromEnum RcTokenTypeBind = 290
    fromEnum RcTokenTypeWidget = 291
    fromEnum RcTokenTypeWidgetClass = 292
    fromEnum RcTokenTypeClass = 293
    fromEnum RcTokenTypeLowest = 294
    fromEnum RcTokenTypeGtk = 295
    fromEnum RcTokenTypeApplication = 296
    fromEnum RcTokenTypeTheme = 297
    fromEnum RcTokenTypeRc = 298
    fromEnum RcTokenTypeHighest = 299
    fromEnum RcTokenTypeEngine = 300
    fromEnum RcTokenTypeModulePath = 301
    fromEnum RcTokenTypeImModulePath = 302
    fromEnum RcTokenTypeImModuleFile = 303
    fromEnum RcTokenTypeStock = 304
    fromEnum RcTokenTypeLtr = 305
    fromEnum RcTokenTypeRtl = 306
    fromEnum RcTokenTypeColor = 307
    fromEnum RcTokenTypeUnbind = 308
    fromEnum RcTokenTypeLast = 309
    fromEnum (AnotherRcTokenType k :: Int
k) = Int
k

    toEnum :: Int -> RcTokenType
toEnum 270 = RcTokenType
RcTokenTypeInvalid
    toEnum 271 = RcTokenType
RcTokenTypeInclude
    toEnum 272 = RcTokenType
RcTokenTypeNormal
    toEnum 273 = RcTokenType
RcTokenTypeActive
    toEnum 274 = RcTokenType
RcTokenTypePrelight
    toEnum 275 = RcTokenType
RcTokenTypeSelected
    toEnum 276 = RcTokenType
RcTokenTypeInsensitive
    toEnum 277 = RcTokenType
RcTokenTypeFg
    toEnum 278 = RcTokenType
RcTokenTypeBg
    toEnum 279 = RcTokenType
RcTokenTypeText
    toEnum 280 = RcTokenType
RcTokenTypeBase
    toEnum 281 = RcTokenType
RcTokenTypeXthickness
    toEnum 282 = RcTokenType
RcTokenTypeYthickness
    toEnum 283 = RcTokenType
RcTokenTypeFont
    toEnum 284 = RcTokenType
RcTokenTypeFontset
    toEnum 285 = RcTokenType
RcTokenTypeFontName
    toEnum 286 = RcTokenType
RcTokenTypeBgPixmap
    toEnum 287 = RcTokenType
RcTokenTypePixmapPath
    toEnum 288 = RcTokenType
RcTokenTypeStyle
    toEnum 289 = RcTokenType
RcTokenTypeBinding
    toEnum 290 = RcTokenType
RcTokenTypeBind
    toEnum 291 = RcTokenType
RcTokenTypeWidget
    toEnum 292 = RcTokenType
RcTokenTypeWidgetClass
    toEnum 293 = RcTokenType
RcTokenTypeClass
    toEnum 294 = RcTokenType
RcTokenTypeLowest
    toEnum 295 = RcTokenType
RcTokenTypeGtk
    toEnum 296 = RcTokenType
RcTokenTypeApplication
    toEnum 297 = RcTokenType
RcTokenTypeTheme
    toEnum 298 = RcTokenType
RcTokenTypeRc
    toEnum 299 = RcTokenType
RcTokenTypeHighest
    toEnum 300 = RcTokenType
RcTokenTypeEngine
    toEnum 301 = RcTokenType
RcTokenTypeModulePath
    toEnum 302 = RcTokenType
RcTokenTypeImModulePath
    toEnum 303 = RcTokenType
RcTokenTypeImModuleFile
    toEnum 304 = RcTokenType
RcTokenTypeStock
    toEnum 305 = RcTokenType
RcTokenTypeLtr
    toEnum 306 = RcTokenType
RcTokenTypeRtl
    toEnum 307 = RcTokenType
RcTokenTypeColor
    toEnum 308 = RcTokenType
RcTokenTypeUnbind
    toEnum 309 = RcTokenType
RcTokenTypeLast
    toEnum k :: Int
k = Int -> RcTokenType
AnotherRcTokenType Int
k

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

foreign import ccall "gtk_rc_token_type_get_type" c_gtk_rc_token_type_get_type :: 
    IO GType

instance BoxedEnum RcTokenType where
    boxedEnumType :: RcTokenType -> IO GType
boxedEnumType _ = IO GType
c_gtk_rc_token_type_get_type

-- Enum PropagationPhase
-- | Describes the stage at which events are fed into a t'GI.Gtk.Objects.EventController.EventController'.
-- 
-- /Since: 3.14/
data PropagationPhase = 
      PropagationPhaseNone
    -- ^ Events are not delivered automatically. Those can be
    --   manually fed through 'GI.Gtk.Objects.EventController.eventControllerHandleEvent'. This should
    --   only be used when full control about when, or whether the controller
    --   handles the event is needed.
    | PropagationPhaseCapture
    -- ^ Events are delivered in the capture phase. The
    --   capture phase happens before the bubble phase, runs from the toplevel down
    --   to the event widget. This option should only be used on containers that
    --   might possibly handle events before their children do.
    | PropagationPhaseBubble
    -- ^ Events are delivered in the bubble phase. The bubble
    --   phase happens after the capture phase, and before the default handlers
    --   are run. This phase runs from the event widget, up to the toplevel.
    | PropagationPhaseTarget
    -- ^ Events are delivered in the default widget event handlers,
    --   note that widget implementations must chain up on button, motion, touch and
    --   grab broken handlers for controllers in this phase to be run.
    | AnotherPropagationPhase Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PropagationPhase -> ShowS
[PropagationPhase] -> ShowS
PropagationPhase -> String
(Int -> PropagationPhase -> ShowS)
-> (PropagationPhase -> String)
-> ([PropagationPhase] -> ShowS)
-> Show PropagationPhase
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PropagationPhase] -> ShowS
$cshowList :: [PropagationPhase] -> ShowS
show :: PropagationPhase -> String
$cshow :: PropagationPhase -> String
showsPrec :: Int -> PropagationPhase -> ShowS
$cshowsPrec :: Int -> PropagationPhase -> ShowS
Show, PropagationPhase -> PropagationPhase -> Bool
(PropagationPhase -> PropagationPhase -> Bool)
-> (PropagationPhase -> PropagationPhase -> Bool)
-> Eq PropagationPhase
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PropagationPhase -> PropagationPhase -> Bool
$c/= :: PropagationPhase -> PropagationPhase -> Bool
== :: PropagationPhase -> PropagationPhase -> Bool
$c== :: PropagationPhase -> PropagationPhase -> Bool
Eq)

instance P.Enum PropagationPhase where
    fromEnum :: PropagationPhase -> Int
fromEnum PropagationPhaseNone = 0
    fromEnum PropagationPhaseCapture = 1
    fromEnum PropagationPhaseBubble = 2
    fromEnum PropagationPhaseTarget = 3
    fromEnum (AnotherPropagationPhase k :: Int
k) = Int
k

    toEnum :: Int -> PropagationPhase
toEnum 0 = PropagationPhase
PropagationPhaseNone
    toEnum 1 = PropagationPhase
PropagationPhaseCapture
    toEnum 2 = PropagationPhase
PropagationPhaseBubble
    toEnum 3 = PropagationPhase
PropagationPhaseTarget
    toEnum k :: Int
k = Int -> PropagationPhase
AnotherPropagationPhase Int
k

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

foreign import ccall "gtk_propagation_phase_get_type" c_gtk_propagation_phase_get_type :: 
    IO GType

instance BoxedEnum PropagationPhase where
    boxedEnumType :: PropagationPhase -> IO GType
boxedEnumType _ = IO GType
c_gtk_propagation_phase_get_type

-- Enum PrintStatus
-- | The status gives a rough indication of the completion of a running
-- print operation.
data PrintStatus = 
      PrintStatusInitial
    -- ^ The printing has not started yet; this
    --     status is set initially, and while the print dialog is shown.
    | PrintStatusPreparing
    -- ^ This status is set while the begin-print
    --     signal is emitted and during pagination.
    | PrintStatusGeneratingData
    -- ^ This status is set while the
    --     pages are being rendered.
    | PrintStatusSendingData
    -- ^ The print job is being sent off to the
    --     printer.
    | PrintStatusPending
    -- ^ The print job has been sent to the printer,
    --     but is not printed for some reason, e.g. the printer may be stopped.
    | PrintStatusPendingIssue
    -- ^ Some problem has occurred during
    --     printing, e.g. a paper jam.
    | PrintStatusPrinting
    -- ^ The printer is processing the print job.
    | PrintStatusFinished
    -- ^ The printing has been completed successfully.
    | PrintStatusFinishedAborted
    -- ^ The printing has been aborted.
    | AnotherPrintStatus Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PrintStatus -> ShowS
[PrintStatus] -> ShowS
PrintStatus -> String
(Int -> PrintStatus -> ShowS)
-> (PrintStatus -> String)
-> ([PrintStatus] -> ShowS)
-> Show PrintStatus
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PrintStatus] -> ShowS
$cshowList :: [PrintStatus] -> ShowS
show :: PrintStatus -> String
$cshow :: PrintStatus -> String
showsPrec :: Int -> PrintStatus -> ShowS
$cshowsPrec :: Int -> PrintStatus -> ShowS
Show, PrintStatus -> PrintStatus -> Bool
(PrintStatus -> PrintStatus -> Bool)
-> (PrintStatus -> PrintStatus -> Bool) -> Eq PrintStatus
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PrintStatus -> PrintStatus -> Bool
$c/= :: PrintStatus -> PrintStatus -> Bool
== :: PrintStatus -> PrintStatus -> Bool
$c== :: PrintStatus -> PrintStatus -> Bool
Eq)

instance P.Enum PrintStatus where
    fromEnum :: PrintStatus -> Int
fromEnum PrintStatusInitial = 0
    fromEnum PrintStatusPreparing = 1
    fromEnum PrintStatusGeneratingData = 2
    fromEnum PrintStatusSendingData = 3
    fromEnum PrintStatusPending = 4
    fromEnum PrintStatusPendingIssue = 5
    fromEnum PrintStatusPrinting = 6
    fromEnum PrintStatusFinished = 7
    fromEnum PrintStatusFinishedAborted = 8
    fromEnum (AnotherPrintStatus k :: Int
k) = Int
k

    toEnum :: Int -> PrintStatus
toEnum 0 = PrintStatus
PrintStatusInitial
    toEnum 1 = PrintStatus
PrintStatusPreparing
    toEnum 2 = PrintStatus
PrintStatusGeneratingData
    toEnum 3 = PrintStatus
PrintStatusSendingData
    toEnum 4 = PrintStatus
PrintStatusPending
    toEnum 5 = PrintStatus
PrintStatusPendingIssue
    toEnum 6 = PrintStatus
PrintStatusPrinting
    toEnum 7 = PrintStatus
PrintStatusFinished
    toEnum 8 = PrintStatus
PrintStatusFinishedAborted
    toEnum k :: Int
k = Int -> PrintStatus
AnotherPrintStatus Int
k

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

foreign import ccall "gtk_print_status_get_type" c_gtk_print_status_get_type :: 
    IO GType

instance BoxedEnum PrintStatus where
    boxedEnumType :: PrintStatus -> IO GType
boxedEnumType _ = IO GType
c_gtk_print_status_get_type

-- Enum PrintQuality
-- | See also 'GI.Gtk.Objects.PrintSettings.printSettingsSetQuality'.
data PrintQuality = 
      PrintQualityLow
    -- ^ Low quality.
    | PrintQualityNormal
    -- ^ Normal quality.
    | PrintQualityHigh
    -- ^ High quality.
    | PrintQualityDraft
    -- ^ Draft quality.
    | AnotherPrintQuality Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PrintQuality -> ShowS
[PrintQuality] -> ShowS
PrintQuality -> String
(Int -> PrintQuality -> ShowS)
-> (PrintQuality -> String)
-> ([PrintQuality] -> ShowS)
-> Show PrintQuality
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PrintQuality] -> ShowS
$cshowList :: [PrintQuality] -> ShowS
show :: PrintQuality -> String
$cshow :: PrintQuality -> String
showsPrec :: Int -> PrintQuality -> ShowS
$cshowsPrec :: Int -> PrintQuality -> ShowS
Show, PrintQuality -> PrintQuality -> Bool
(PrintQuality -> PrintQuality -> Bool)
-> (PrintQuality -> PrintQuality -> Bool) -> Eq PrintQuality
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PrintQuality -> PrintQuality -> Bool
$c/= :: PrintQuality -> PrintQuality -> Bool
== :: PrintQuality -> PrintQuality -> Bool
$c== :: PrintQuality -> PrintQuality -> Bool
Eq)

instance P.Enum PrintQuality where
    fromEnum :: PrintQuality -> Int
fromEnum PrintQualityLow = 0
    fromEnum PrintQualityNormal = 1
    fromEnum PrintQualityHigh = 2
    fromEnum PrintQualityDraft = 3
    fromEnum (AnotherPrintQuality k :: Int
k) = Int
k

    toEnum :: Int -> PrintQuality
toEnum 0 = PrintQuality
PrintQualityLow
    toEnum 1 = PrintQuality
PrintQualityNormal
    toEnum 2 = PrintQuality
PrintQualityHigh
    toEnum 3 = PrintQuality
PrintQualityDraft
    toEnum k :: Int
k = Int -> PrintQuality
AnotherPrintQuality Int
k

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

foreign import ccall "gtk_print_quality_get_type" c_gtk_print_quality_get_type :: 
    IO GType

instance BoxedEnum PrintQuality where
    boxedEnumType :: PrintQuality -> IO GType
boxedEnumType _ = IO GType
c_gtk_print_quality_get_type

-- Enum PrintPages
-- | See also @/gtk_print_job_set_pages()/@
data PrintPages = 
      PrintPagesAll
    -- ^ All pages.
    | PrintPagesCurrent
    -- ^ Current page.
    | PrintPagesRanges
    -- ^ Range of pages.
    | PrintPagesSelection
    -- ^ Selected pages.
    | AnotherPrintPages Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PrintPages -> ShowS
[PrintPages] -> ShowS
PrintPages -> String
(Int -> PrintPages -> ShowS)
-> (PrintPages -> String)
-> ([PrintPages] -> ShowS)
-> Show PrintPages
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PrintPages] -> ShowS
$cshowList :: [PrintPages] -> ShowS
show :: PrintPages -> String
$cshow :: PrintPages -> String
showsPrec :: Int -> PrintPages -> ShowS
$cshowsPrec :: Int -> PrintPages -> ShowS
Show, PrintPages -> PrintPages -> Bool
(PrintPages -> PrintPages -> Bool)
-> (PrintPages -> PrintPages -> Bool) -> Eq PrintPages
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PrintPages -> PrintPages -> Bool
$c/= :: PrintPages -> PrintPages -> Bool
== :: PrintPages -> PrintPages -> Bool
$c== :: PrintPages -> PrintPages -> Bool
Eq)

instance P.Enum PrintPages where
    fromEnum :: PrintPages -> Int
fromEnum PrintPagesAll = 0
    fromEnum PrintPagesCurrent = 1
    fromEnum PrintPagesRanges = 2
    fromEnum PrintPagesSelection = 3
    fromEnum (AnotherPrintPages k :: Int
k) = Int
k

    toEnum :: Int -> PrintPages
toEnum 0 = PrintPages
PrintPagesAll
    toEnum 1 = PrintPages
PrintPagesCurrent
    toEnum 2 = PrintPages
PrintPagesRanges
    toEnum 3 = PrintPages
PrintPagesSelection
    toEnum k :: Int
k = Int -> PrintPages
AnotherPrintPages Int
k

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

foreign import ccall "gtk_print_pages_get_type" c_gtk_print_pages_get_type :: 
    IO GType

instance BoxedEnum PrintPages where
    boxedEnumType :: PrintPages -> IO GType
boxedEnumType _ = IO GType
c_gtk_print_pages_get_type

-- Enum PrintOperationResult
-- | A value of this type is returned by 'GI.Gtk.Objects.PrintOperation.printOperationRun'.
data PrintOperationResult = 
      PrintOperationResultError
    -- ^ An error has occurred.
    | PrintOperationResultApply
    -- ^ The print settings should be stored.
    | PrintOperationResultCancel
    -- ^ The print operation has been canceled,
    --     the print settings should not be stored.
    | PrintOperationResultInProgress
    -- ^ The print operation is not complete
    --     yet. This value will only be returned when running asynchronously.
    | AnotherPrintOperationResult Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PrintOperationResult -> ShowS
[PrintOperationResult] -> ShowS
PrintOperationResult -> String
(Int -> PrintOperationResult -> ShowS)
-> (PrintOperationResult -> String)
-> ([PrintOperationResult] -> ShowS)
-> Show PrintOperationResult
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PrintOperationResult] -> ShowS
$cshowList :: [PrintOperationResult] -> ShowS
show :: PrintOperationResult -> String
$cshow :: PrintOperationResult -> String
showsPrec :: Int -> PrintOperationResult -> ShowS
$cshowsPrec :: Int -> PrintOperationResult -> ShowS
Show, PrintOperationResult -> PrintOperationResult -> Bool
(PrintOperationResult -> PrintOperationResult -> Bool)
-> (PrintOperationResult -> PrintOperationResult -> Bool)
-> Eq PrintOperationResult
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PrintOperationResult -> PrintOperationResult -> Bool
$c/= :: PrintOperationResult -> PrintOperationResult -> Bool
== :: PrintOperationResult -> PrintOperationResult -> Bool
$c== :: PrintOperationResult -> PrintOperationResult -> Bool
Eq)

instance P.Enum PrintOperationResult where
    fromEnum :: PrintOperationResult -> Int
fromEnum PrintOperationResultError = 0
    fromEnum PrintOperationResultApply = 1
    fromEnum PrintOperationResultCancel = 2
    fromEnum PrintOperationResultInProgress = 3
    fromEnum (AnotherPrintOperationResult k :: Int
k) = Int
k

    toEnum :: Int -> PrintOperationResult
toEnum 0 = PrintOperationResult
PrintOperationResultError
    toEnum 1 = PrintOperationResult
PrintOperationResultApply
    toEnum 2 = PrintOperationResult
PrintOperationResultCancel
    toEnum 3 = PrintOperationResult
PrintOperationResultInProgress
    toEnum k :: Int
k = Int -> PrintOperationResult
AnotherPrintOperationResult Int
k

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

foreign import ccall "gtk_print_operation_result_get_type" c_gtk_print_operation_result_get_type :: 
    IO GType

instance BoxedEnum PrintOperationResult where
    boxedEnumType :: PrintOperationResult -> IO GType
boxedEnumType _ = IO GType
c_gtk_print_operation_result_get_type

-- Enum PrintOperationAction
-- | The /@action@/ parameter to 'GI.Gtk.Objects.PrintOperation.printOperationRun'
-- determines what action the print operation should perform.
data PrintOperationAction = 
      PrintOperationActionPrintDialog
    -- ^ Show the print dialog.
    | PrintOperationActionPrint
    -- ^ Start to print without showing
    --     the print dialog, based on the current print settings.
    | PrintOperationActionPreview
    -- ^ Show the print preview.
    | PrintOperationActionExport
    -- ^ Export to a file. This requires
    --     the export-filename property to be set.
    | AnotherPrintOperationAction Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PrintOperationAction -> ShowS
[PrintOperationAction] -> ShowS
PrintOperationAction -> String
(Int -> PrintOperationAction -> ShowS)
-> (PrintOperationAction -> String)
-> ([PrintOperationAction] -> ShowS)
-> Show PrintOperationAction
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PrintOperationAction] -> ShowS
$cshowList :: [PrintOperationAction] -> ShowS
show :: PrintOperationAction -> String
$cshow :: PrintOperationAction -> String
showsPrec :: Int -> PrintOperationAction -> ShowS
$cshowsPrec :: Int -> PrintOperationAction -> ShowS
Show, PrintOperationAction -> PrintOperationAction -> Bool
(PrintOperationAction -> PrintOperationAction -> Bool)
-> (PrintOperationAction -> PrintOperationAction -> Bool)
-> Eq PrintOperationAction
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PrintOperationAction -> PrintOperationAction -> Bool
$c/= :: PrintOperationAction -> PrintOperationAction -> Bool
== :: PrintOperationAction -> PrintOperationAction -> Bool
$c== :: PrintOperationAction -> PrintOperationAction -> Bool
Eq)

instance P.Enum PrintOperationAction where
    fromEnum :: PrintOperationAction -> Int
fromEnum PrintOperationActionPrintDialog = 0
    fromEnum PrintOperationActionPrint = 1
    fromEnum PrintOperationActionPreview = 2
    fromEnum PrintOperationActionExport = 3
    fromEnum (AnotherPrintOperationAction k :: Int
k) = Int
k

    toEnum :: Int -> PrintOperationAction
toEnum 0 = PrintOperationAction
PrintOperationActionPrintDialog
    toEnum 1 = PrintOperationAction
PrintOperationActionPrint
    toEnum 2 = PrintOperationAction
PrintOperationActionPreview
    toEnum 3 = PrintOperationAction
PrintOperationActionExport
    toEnum k :: Int
k = Int -> PrintOperationAction
AnotherPrintOperationAction Int
k

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

foreign import ccall "gtk_print_operation_action_get_type" c_gtk_print_operation_action_get_type :: 
    IO GType

instance BoxedEnum PrintOperationAction where
    boxedEnumType :: PrintOperationAction -> IO GType
boxedEnumType _ = IO GType
c_gtk_print_operation_action_get_type

-- Enum PrintError
-- | Error codes that identify various errors that can occur while
-- using the GTK+ printing support.
data PrintError = 
      PrintErrorGeneral
    -- ^ An unspecified error occurred.
    | PrintErrorInternalError
    -- ^ An internal error occurred.
    | PrintErrorNomem
    -- ^ A memory allocation failed.
    | PrintErrorInvalidFile
    -- ^ An error occurred while loading a page setup
    --     or paper size from a key file.
    | AnotherPrintError Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PrintError -> ShowS
[PrintError] -> ShowS
PrintError -> String
(Int -> PrintError -> ShowS)
-> (PrintError -> String)
-> ([PrintError] -> ShowS)
-> Show PrintError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PrintError] -> ShowS
$cshowList :: [PrintError] -> ShowS
show :: PrintError -> String
$cshow :: PrintError -> String
showsPrec :: Int -> PrintError -> ShowS
$cshowsPrec :: Int -> PrintError -> ShowS
Show, PrintError -> PrintError -> Bool
(PrintError -> PrintError -> Bool)
-> (PrintError -> PrintError -> Bool) -> Eq PrintError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PrintError -> PrintError -> Bool
$c/= :: PrintError -> PrintError -> Bool
== :: PrintError -> PrintError -> Bool
$c== :: PrintError -> PrintError -> Bool
Eq)

instance P.Enum PrintError where
    fromEnum :: PrintError -> Int
fromEnum PrintErrorGeneral = 0
    fromEnum PrintErrorInternalError = 1
    fromEnum PrintErrorNomem = 2
    fromEnum PrintErrorInvalidFile = 3
    fromEnum (AnotherPrintError k :: Int
k) = Int
k

    toEnum :: Int -> PrintError
toEnum 0 = PrintError
PrintErrorGeneral
    toEnum 1 = PrintError
PrintErrorInternalError
    toEnum 2 = PrintError
PrintErrorNomem
    toEnum 3 = PrintError
PrintErrorInvalidFile
    toEnum k :: Int
k = Int -> PrintError
AnotherPrintError Int
k

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

instance GErrorClass PrintError where
    gerrorClassDomain :: PrintError -> Text
gerrorClassDomain _ = "gtk-print-error-quark"

-- | Catch exceptions of type `PrintError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
catchPrintError ::
    IO a ->
    (PrintError -> GErrorMessage -> IO a) ->
    IO a
catchPrintError :: IO a -> (PrintError -> Text -> IO a) -> IO a
catchPrintError = IO a -> (PrintError -> Text -> IO a) -> IO a
forall err a.
GErrorClass err =>
IO a -> (err -> Text -> IO a) -> IO a
catchGErrorJustDomain

-- | Handle exceptions of type `PrintError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
handlePrintError ::
    (PrintError -> GErrorMessage -> IO a) ->
    IO a ->
    IO a
handlePrintError :: (PrintError -> Text -> IO a) -> IO a -> IO a
handlePrintError = (PrintError -> Text -> IO a) -> IO a -> IO a
forall err a.
GErrorClass err =>
(err -> Text -> IO a) -> IO a -> IO a
handleGErrorJustDomain

foreign import ccall "gtk_print_error_get_type" c_gtk_print_error_get_type :: 
    IO GType

instance BoxedEnum PrintError where
    boxedEnumType :: PrintError -> IO GType
boxedEnumType _ = IO GType
c_gtk_print_error_get_type

-- Enum PrintDuplex
-- | See also 'GI.Gtk.Objects.PrintSettings.printSettingsSetDuplex'.
data PrintDuplex = 
      PrintDuplexSimplex
    -- ^ No duplex.
    | PrintDuplexHorizontal
    -- ^ Horizontal duplex.
    | PrintDuplexVertical
    -- ^ Vertical duplex.
    | AnotherPrintDuplex Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PrintDuplex -> ShowS
[PrintDuplex] -> ShowS
PrintDuplex -> String
(Int -> PrintDuplex -> ShowS)
-> (PrintDuplex -> String)
-> ([PrintDuplex] -> ShowS)
-> Show PrintDuplex
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PrintDuplex] -> ShowS
$cshowList :: [PrintDuplex] -> ShowS
show :: PrintDuplex -> String
$cshow :: PrintDuplex -> String
showsPrec :: Int -> PrintDuplex -> ShowS
$cshowsPrec :: Int -> PrintDuplex -> ShowS
Show, PrintDuplex -> PrintDuplex -> Bool
(PrintDuplex -> PrintDuplex -> Bool)
-> (PrintDuplex -> PrintDuplex -> Bool) -> Eq PrintDuplex
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PrintDuplex -> PrintDuplex -> Bool
$c/= :: PrintDuplex -> PrintDuplex -> Bool
== :: PrintDuplex -> PrintDuplex -> Bool
$c== :: PrintDuplex -> PrintDuplex -> Bool
Eq)

instance P.Enum PrintDuplex where
    fromEnum :: PrintDuplex -> Int
fromEnum PrintDuplexSimplex = 0
    fromEnum PrintDuplexHorizontal = 1
    fromEnum PrintDuplexVertical = 2
    fromEnum (AnotherPrintDuplex k :: Int
k) = Int
k

    toEnum :: Int -> PrintDuplex
toEnum 0 = PrintDuplex
PrintDuplexSimplex
    toEnum 1 = PrintDuplex
PrintDuplexHorizontal
    toEnum 2 = PrintDuplex
PrintDuplexVertical
    toEnum k :: Int
k = Int -> PrintDuplex
AnotherPrintDuplex Int
k

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

foreign import ccall "gtk_print_duplex_get_type" c_gtk_print_duplex_get_type :: 
    IO GType

instance BoxedEnum PrintDuplex where
    boxedEnumType :: PrintDuplex -> IO GType
boxedEnumType _ = IO GType
c_gtk_print_duplex_get_type

-- Enum PositionType
-- | Describes which edge of a widget a certain feature is positioned at, e.g. the
-- tabs of a t'GI.Gtk.Objects.Notebook.Notebook', the handle of a t'GI.Gtk.Objects.HandleBox.HandleBox' or the label of a
-- t'GI.Gtk.Objects.Scale.Scale'.
data PositionType = 
      PositionTypeLeft
    -- ^ The feature is at the left edge.
    | PositionTypeRight
    -- ^ The feature is at the right edge.
    | PositionTypeTop
    -- ^ The feature is at the top edge.
    | PositionTypeBottom
    -- ^ The feature is at the bottom edge.
    | AnotherPositionType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PositionType -> ShowS
[PositionType] -> ShowS
PositionType -> String
(Int -> PositionType -> ShowS)
-> (PositionType -> String)
-> ([PositionType] -> ShowS)
-> Show PositionType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PositionType] -> ShowS
$cshowList :: [PositionType] -> ShowS
show :: PositionType -> String
$cshow :: PositionType -> String
showsPrec :: Int -> PositionType -> ShowS
$cshowsPrec :: Int -> PositionType -> ShowS
Show, PositionType -> PositionType -> Bool
(PositionType -> PositionType -> Bool)
-> (PositionType -> PositionType -> Bool) -> Eq PositionType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PositionType -> PositionType -> Bool
$c/= :: PositionType -> PositionType -> Bool
== :: PositionType -> PositionType -> Bool
$c== :: PositionType -> PositionType -> Bool
Eq)

instance P.Enum PositionType where
    fromEnum :: PositionType -> Int
fromEnum PositionTypeLeft = 0
    fromEnum PositionTypeRight = 1
    fromEnum PositionTypeTop = 2
    fromEnum PositionTypeBottom = 3
    fromEnum (AnotherPositionType k :: Int
k) = Int
k

    toEnum :: Int -> PositionType
toEnum 0 = PositionType
PositionTypeLeft
    toEnum 1 = PositionType
PositionTypeRight
    toEnum 2 = PositionType
PositionTypeTop
    toEnum 3 = PositionType
PositionTypeBottom
    toEnum k :: Int
k = Int -> PositionType
AnotherPositionType Int
k

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

foreign import ccall "gtk_position_type_get_type" c_gtk_position_type_get_type :: 
    IO GType

instance BoxedEnum PositionType where
    boxedEnumType :: PositionType -> IO GType
boxedEnumType _ = IO GType
c_gtk_position_type_get_type

-- Enum PopoverConstraint
-- | Describes constraints to positioning of popovers. More values
-- may be added to this enumeration in the future.
-- 
-- /Since: 3.20/
data PopoverConstraint = 
      PopoverConstraintNone
    -- ^ Don\'t constrain the popover position
    --   beyond what is imposed by the implementation
    | PopoverConstraintWindow
    -- ^ Constrain the popover to the boundaries
    --   of the window that it is attached to
    | AnotherPopoverConstraint Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PopoverConstraint -> ShowS
[PopoverConstraint] -> ShowS
PopoverConstraint -> String
(Int -> PopoverConstraint -> ShowS)
-> (PopoverConstraint -> String)
-> ([PopoverConstraint] -> ShowS)
-> Show PopoverConstraint
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PopoverConstraint] -> ShowS
$cshowList :: [PopoverConstraint] -> ShowS
show :: PopoverConstraint -> String
$cshow :: PopoverConstraint -> String
showsPrec :: Int -> PopoverConstraint -> ShowS
$cshowsPrec :: Int -> PopoverConstraint -> ShowS
Show, PopoverConstraint -> PopoverConstraint -> Bool
(PopoverConstraint -> PopoverConstraint -> Bool)
-> (PopoverConstraint -> PopoverConstraint -> Bool)
-> Eq PopoverConstraint
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PopoverConstraint -> PopoverConstraint -> Bool
$c/= :: PopoverConstraint -> PopoverConstraint -> Bool
== :: PopoverConstraint -> PopoverConstraint -> Bool
$c== :: PopoverConstraint -> PopoverConstraint -> Bool
Eq)

instance P.Enum PopoverConstraint where
    fromEnum :: PopoverConstraint -> Int
fromEnum PopoverConstraintNone = 0
    fromEnum PopoverConstraintWindow = 1
    fromEnum (AnotherPopoverConstraint k :: Int
k) = Int
k

    toEnum :: Int -> PopoverConstraint
toEnum 0 = PopoverConstraint
PopoverConstraintNone
    toEnum 1 = PopoverConstraint
PopoverConstraintWindow
    toEnum k :: Int
k = Int -> PopoverConstraint
AnotherPopoverConstraint Int
k

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

foreign import ccall "gtk_popover_constraint_get_type" c_gtk_popover_constraint_get_type :: 
    IO GType

instance BoxedEnum PopoverConstraint where
    boxedEnumType :: PopoverConstraint -> IO GType
boxedEnumType _ = IO GType
c_gtk_popover_constraint_get_type

-- Enum PolicyType
-- | Determines how the size should be computed to achieve the one of the
-- visibility mode for the scrollbars.
data PolicyType = 
      PolicyTypeAlways
    -- ^ The scrollbar is always visible. The view size is
    --  independent of the content.
    | PolicyTypeAutomatic
    -- ^ The scrollbar will appear and disappear as necessary.
    --  For example, when all of a t'GI.Gtk.Objects.TreeView.TreeView' can not be seen.
    | PolicyTypeNever
    -- ^ The scrollbar should never appear. In this mode the
    --  content determines the size.
    | PolicyTypeExternal
    -- ^ Don\'t show a scrollbar, but don\'t force the
    --  size to follow the content. This can be used e.g. to make multiple
    --  scrolled windows share a scrollbar. Since: 3.16
    | AnotherPolicyType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PolicyType -> ShowS
[PolicyType] -> ShowS
PolicyType -> String
(Int -> PolicyType -> ShowS)
-> (PolicyType -> String)
-> ([PolicyType] -> ShowS)
-> Show PolicyType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PolicyType] -> ShowS
$cshowList :: [PolicyType] -> ShowS
show :: PolicyType -> String
$cshow :: PolicyType -> String
showsPrec :: Int -> PolicyType -> ShowS
$cshowsPrec :: Int -> PolicyType -> ShowS
Show, PolicyType -> PolicyType -> Bool
(PolicyType -> PolicyType -> Bool)
-> (PolicyType -> PolicyType -> Bool) -> Eq PolicyType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PolicyType -> PolicyType -> Bool
$c/= :: PolicyType -> PolicyType -> Bool
== :: PolicyType -> PolicyType -> Bool
$c== :: PolicyType -> PolicyType -> Bool
Eq)

instance P.Enum PolicyType where
    fromEnum :: PolicyType -> Int
fromEnum PolicyTypeAlways = 0
    fromEnum PolicyTypeAutomatic = 1
    fromEnum PolicyTypeNever = 2
    fromEnum PolicyTypeExternal = 3
    fromEnum (AnotherPolicyType k :: Int
k) = Int
k

    toEnum :: Int -> PolicyType
toEnum 0 = PolicyType
PolicyTypeAlways
    toEnum 1 = PolicyType
PolicyTypeAutomatic
    toEnum 2 = PolicyType
PolicyTypeNever
    toEnum 3 = PolicyType
PolicyTypeExternal
    toEnum k :: Int
k = Int -> PolicyType
AnotherPolicyType Int
k

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

foreign import ccall "gtk_policy_type_get_type" c_gtk_policy_type_get_type :: 
    IO GType

instance BoxedEnum PolicyType where
    boxedEnumType :: PolicyType -> IO GType
boxedEnumType _ = IO GType
c_gtk_policy_type_get_type

-- Enum PathType
{-# DEPRECATED PathType ["(Since version 3.0)"] #-}
-- | Widget path types.
-- See also 'GI.Gtk.Structs.BindingSet.bindingSetAddPath'.
data PathType = 
      PathTypeWidget
    -- ^ Deprecated
    | PathTypeWidgetClass
    -- ^ Deprecated
    | PathTypeClass
    -- ^ Deprecated
    | AnotherPathType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PathType -> ShowS
[PathType] -> ShowS
PathType -> String
(Int -> PathType -> ShowS)
-> (PathType -> String) -> ([PathType] -> ShowS) -> Show PathType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PathType] -> ShowS
$cshowList :: [PathType] -> ShowS
show :: PathType -> String
$cshow :: PathType -> String
showsPrec :: Int -> PathType -> ShowS
$cshowsPrec :: Int -> PathType -> ShowS
Show, PathType -> PathType -> Bool
(PathType -> PathType -> Bool)
-> (PathType -> PathType -> Bool) -> Eq PathType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PathType -> PathType -> Bool
$c/= :: PathType -> PathType -> Bool
== :: PathType -> PathType -> Bool
$c== :: PathType -> PathType -> Bool
Eq)

instance P.Enum PathType where
    fromEnum :: PathType -> Int
fromEnum PathTypeWidget = 0
    fromEnum PathTypeWidgetClass = 1
    fromEnum PathTypeClass = 2
    fromEnum (AnotherPathType k :: Int
k) = Int
k

    toEnum :: Int -> PathType
toEnum 0 = PathType
PathTypeWidget
    toEnum 1 = PathType
PathTypeWidgetClass
    toEnum 2 = PathType
PathTypeClass
    toEnum k :: Int
k = Int -> PathType
AnotherPathType Int
k

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

foreign import ccall "gtk_path_type_get_type" c_gtk_path_type_get_type :: 
    IO GType

instance BoxedEnum PathType where
    boxedEnumType :: PathType -> IO GType
boxedEnumType _ = IO GType
c_gtk_path_type_get_type

-- Enum PathPriorityType
{-# DEPRECATED PathPriorityType ["(Since version 3.0)"] #-}
-- | Priorities for path lookups.
-- See also 'GI.Gtk.Structs.BindingSet.bindingSetAddPath'.
data PathPriorityType = 
      PathPriorityTypeLowest
    -- ^ Deprecated
    | PathPriorityTypeGtk
    -- ^ Deprecated
    | PathPriorityTypeApplication
    -- ^ Deprecated
    | PathPriorityTypeTheme
    -- ^ Deprecated
    | PathPriorityTypeRc
    -- ^ Deprecated
    | PathPriorityTypeHighest
    -- ^ Deprecated
    | AnotherPathPriorityType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PathPriorityType -> ShowS
[PathPriorityType] -> ShowS
PathPriorityType -> String
(Int -> PathPriorityType -> ShowS)
-> (PathPriorityType -> String)
-> ([PathPriorityType] -> ShowS)
-> Show PathPriorityType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PathPriorityType] -> ShowS
$cshowList :: [PathPriorityType] -> ShowS
show :: PathPriorityType -> String
$cshow :: PathPriorityType -> String
showsPrec :: Int -> PathPriorityType -> ShowS
$cshowsPrec :: Int -> PathPriorityType -> ShowS
Show, PathPriorityType -> PathPriorityType -> Bool
(PathPriorityType -> PathPriorityType -> Bool)
-> (PathPriorityType -> PathPriorityType -> Bool)
-> Eq PathPriorityType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PathPriorityType -> PathPriorityType -> Bool
$c/= :: PathPriorityType -> PathPriorityType -> Bool
== :: PathPriorityType -> PathPriorityType -> Bool
$c== :: PathPriorityType -> PathPriorityType -> Bool
Eq)

instance P.Enum PathPriorityType where
    fromEnum :: PathPriorityType -> Int
fromEnum PathPriorityTypeLowest = 0
    fromEnum PathPriorityTypeGtk = 4
    fromEnum PathPriorityTypeApplication = 8
    fromEnum PathPriorityTypeTheme = 10
    fromEnum PathPriorityTypeRc = 12
    fromEnum PathPriorityTypeHighest = 15
    fromEnum (AnotherPathPriorityType k :: Int
k) = Int
k

    toEnum :: Int -> PathPriorityType
toEnum 0 = PathPriorityType
PathPriorityTypeLowest
    toEnum 4 = PathPriorityType
PathPriorityTypeGtk
    toEnum 8 = PathPriorityType
PathPriorityTypeApplication
    toEnum 10 = PathPriorityType
PathPriorityTypeTheme
    toEnum 12 = PathPriorityType
PathPriorityTypeRc
    toEnum 15 = PathPriorityType
PathPriorityTypeHighest
    toEnum k :: Int
k = Int -> PathPriorityType
AnotherPathPriorityType Int
k

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

foreign import ccall "gtk_path_priority_type_get_type" c_gtk_path_priority_type_get_type :: 
    IO GType

instance BoxedEnum PathPriorityType where
    boxedEnumType :: PathPriorityType -> IO GType
boxedEnumType _ = IO GType
c_gtk_path_priority_type_get_type

-- Enum PanDirection
-- | Describes the panning direction of a t'GI.Gtk.Objects.GesturePan.GesturePan'
-- 
-- /Since: 3.14/
data PanDirection = 
      PanDirectionLeft
    -- ^ panned towards the left
    | PanDirectionRight
    -- ^ panned towards the right
    | PanDirectionUp
    -- ^ panned upwards
    | PanDirectionDown
    -- ^ panned downwards
    | AnotherPanDirection Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PanDirection -> ShowS
[PanDirection] -> ShowS
PanDirection -> String
(Int -> PanDirection -> ShowS)
-> (PanDirection -> String)
-> ([PanDirection] -> ShowS)
-> Show PanDirection
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PanDirection] -> ShowS
$cshowList :: [PanDirection] -> ShowS
show :: PanDirection -> String
$cshow :: PanDirection -> String
showsPrec :: Int -> PanDirection -> ShowS
$cshowsPrec :: Int -> PanDirection -> ShowS
Show, PanDirection -> PanDirection -> Bool
(PanDirection -> PanDirection -> Bool)
-> (PanDirection -> PanDirection -> Bool) -> Eq PanDirection
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PanDirection -> PanDirection -> Bool
$c/= :: PanDirection -> PanDirection -> Bool
== :: PanDirection -> PanDirection -> Bool
$c== :: PanDirection -> PanDirection -> Bool
Eq)

instance P.Enum PanDirection where
    fromEnum :: PanDirection -> Int
fromEnum PanDirectionLeft = 0
    fromEnum PanDirectionRight = 1
    fromEnum PanDirectionUp = 2
    fromEnum PanDirectionDown = 3
    fromEnum (AnotherPanDirection k :: Int
k) = Int
k

    toEnum :: Int -> PanDirection
toEnum 0 = PanDirection
PanDirectionLeft
    toEnum 1 = PanDirection
PanDirectionRight
    toEnum 2 = PanDirection
PanDirectionUp
    toEnum 3 = PanDirection
PanDirectionDown
    toEnum k :: Int
k = Int -> PanDirection
AnotherPanDirection Int
k

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

foreign import ccall "gtk_pan_direction_get_type" c_gtk_pan_direction_get_type :: 
    IO GType

instance BoxedEnum PanDirection where
    boxedEnumType :: PanDirection -> IO GType
boxedEnumType _ = IO GType
c_gtk_pan_direction_get_type

-- Enum PageSet
-- | See also @/gtk_print_job_set_page_set()/@.
data PageSet = 
      PageSetAll
    -- ^ All pages.
    | PageSetEven
    -- ^ Even pages.
    | PageSetOdd
    -- ^ Odd pages.
    | AnotherPageSet Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PageSet -> ShowS
[PageSet] -> ShowS
PageSet -> String
(Int -> PageSet -> ShowS)
-> (PageSet -> String) -> ([PageSet] -> ShowS) -> Show PageSet
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PageSet] -> ShowS
$cshowList :: [PageSet] -> ShowS
show :: PageSet -> String
$cshow :: PageSet -> String
showsPrec :: Int -> PageSet -> ShowS
$cshowsPrec :: Int -> PageSet -> ShowS
Show, PageSet -> PageSet -> Bool
(PageSet -> PageSet -> Bool)
-> (PageSet -> PageSet -> Bool) -> Eq PageSet
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PageSet -> PageSet -> Bool
$c/= :: PageSet -> PageSet -> Bool
== :: PageSet -> PageSet -> Bool
$c== :: PageSet -> PageSet -> Bool
Eq)

instance P.Enum PageSet where
    fromEnum :: PageSet -> Int
fromEnum PageSetAll = 0
    fromEnum PageSetEven = 1
    fromEnum PageSetOdd = 2
    fromEnum (AnotherPageSet k :: Int
k) = Int
k

    toEnum :: Int -> PageSet
toEnum 0 = PageSet
PageSetAll
    toEnum 1 = PageSet
PageSetEven
    toEnum 2 = PageSet
PageSetOdd
    toEnum k :: Int
k = Int -> PageSet
AnotherPageSet Int
k

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

foreign import ccall "gtk_page_set_get_type" c_gtk_page_set_get_type :: 
    IO GType

instance BoxedEnum PageSet where
    boxedEnumType :: PageSet -> IO GType
boxedEnumType _ = IO GType
c_gtk_page_set_get_type

-- Enum PageOrientation
-- | See also 'GI.Gtk.Objects.PrintSettings.printSettingsSetOrientation'.
data PageOrientation = 
      PageOrientationPortrait
    -- ^ Portrait mode.
    | PageOrientationLandscape
    -- ^ Landscape mode.
    | PageOrientationReversePortrait
    -- ^ Reverse portrait mode.
    | PageOrientationReverseLandscape
    -- ^ Reverse landscape mode.
    | AnotherPageOrientation Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PageOrientation -> ShowS
[PageOrientation] -> ShowS
PageOrientation -> String
(Int -> PageOrientation -> ShowS)
-> (PageOrientation -> String)
-> ([PageOrientation] -> ShowS)
-> Show PageOrientation
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PageOrientation] -> ShowS
$cshowList :: [PageOrientation] -> ShowS
show :: PageOrientation -> String
$cshow :: PageOrientation -> String
showsPrec :: Int -> PageOrientation -> ShowS
$cshowsPrec :: Int -> PageOrientation -> ShowS
Show, PageOrientation -> PageOrientation -> Bool
(PageOrientation -> PageOrientation -> Bool)
-> (PageOrientation -> PageOrientation -> Bool)
-> Eq PageOrientation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PageOrientation -> PageOrientation -> Bool
$c/= :: PageOrientation -> PageOrientation -> Bool
== :: PageOrientation -> PageOrientation -> Bool
$c== :: PageOrientation -> PageOrientation -> Bool
Eq)

instance P.Enum PageOrientation where
    fromEnum :: PageOrientation -> Int
fromEnum PageOrientationPortrait = 0
    fromEnum PageOrientationLandscape = 1
    fromEnum PageOrientationReversePortrait = 2
    fromEnum PageOrientationReverseLandscape = 3
    fromEnum (AnotherPageOrientation k :: Int
k) = Int
k

    toEnum :: Int -> PageOrientation
toEnum 0 = PageOrientation
PageOrientationPortrait
    toEnum 1 = PageOrientation
PageOrientationLandscape
    toEnum 2 = PageOrientation
PageOrientationReversePortrait
    toEnum 3 = PageOrientation
PageOrientationReverseLandscape
    toEnum k :: Int
k = Int -> PageOrientation
AnotherPageOrientation Int
k

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

foreign import ccall "gtk_page_orientation_get_type" c_gtk_page_orientation_get_type :: 
    IO GType

instance BoxedEnum PageOrientation where
    boxedEnumType :: PageOrientation -> IO GType
boxedEnumType _ = IO GType
c_gtk_page_orientation_get_type

-- Enum PadActionType
-- | The type of a pad action.
data PadActionType = 
      PadActionTypeButton
    -- ^ Action is triggered by a pad button
    | PadActionTypeRing
    -- ^ Action is triggered by a pad ring
    | PadActionTypeStrip
    -- ^ Action is triggered by a pad strip
    | AnotherPadActionType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PadActionType -> ShowS
[PadActionType] -> ShowS
PadActionType -> String
(Int -> PadActionType -> ShowS)
-> (PadActionType -> String)
-> ([PadActionType] -> ShowS)
-> Show PadActionType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PadActionType] -> ShowS
$cshowList :: [PadActionType] -> ShowS
show :: PadActionType -> String
$cshow :: PadActionType -> String
showsPrec :: Int -> PadActionType -> ShowS
$cshowsPrec :: Int -> PadActionType -> ShowS
Show, PadActionType -> PadActionType -> Bool
(PadActionType -> PadActionType -> Bool)
-> (PadActionType -> PadActionType -> Bool) -> Eq PadActionType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PadActionType -> PadActionType -> Bool
$c/= :: PadActionType -> PadActionType -> Bool
== :: PadActionType -> PadActionType -> Bool
$c== :: PadActionType -> PadActionType -> Bool
Eq)

instance P.Enum PadActionType where
    fromEnum :: PadActionType -> Int
fromEnum PadActionTypeButton = 0
    fromEnum PadActionTypeRing = 1
    fromEnum PadActionTypeStrip = 2
    fromEnum (AnotherPadActionType k :: Int
k) = Int
k

    toEnum :: Int -> PadActionType
toEnum 0 = PadActionType
PadActionTypeButton
    toEnum 1 = PadActionType
PadActionTypeRing
    toEnum 2 = PadActionType
PadActionTypeStrip
    toEnum k :: Int
k = Int -> PadActionType
AnotherPadActionType Int
k

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

foreign import ccall "gtk_pad_action_type_get_type" c_gtk_pad_action_type_get_type :: 
    IO GType

instance BoxedEnum PadActionType where
    boxedEnumType :: PadActionType -> IO GType
boxedEnumType _ = IO GType
c_gtk_pad_action_type_get_type

-- Enum PackType
-- | Represents the packing location t'GI.Gtk.Objects.Box.Box' children. (See: t'GI.Gtk.Objects.VBox.VBox',
-- t'GI.Gtk.Objects.HBox.HBox', and t'GI.Gtk.Objects.ButtonBox.ButtonBox').
data PackType = 
      PackTypeStart
    -- ^ The child is packed into the start of the box
    | PackTypeEnd
    -- ^ The child is packed into the end of the box
    | AnotherPackType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PackType -> ShowS
[PackType] -> ShowS
PackType -> String
(Int -> PackType -> ShowS)
-> (PackType -> String) -> ([PackType] -> ShowS) -> Show PackType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PackType] -> ShowS
$cshowList :: [PackType] -> ShowS
show :: PackType -> String
$cshow :: PackType -> String
showsPrec :: Int -> PackType -> ShowS
$cshowsPrec :: Int -> PackType -> ShowS
Show, PackType -> PackType -> Bool
(PackType -> PackType -> Bool)
-> (PackType -> PackType -> Bool) -> Eq PackType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PackType -> PackType -> Bool
$c/= :: PackType -> PackType -> Bool
== :: PackType -> PackType -> Bool
$c== :: PackType -> PackType -> Bool
Eq)

instance P.Enum PackType where
    fromEnum :: PackType -> Int
fromEnum PackTypeStart = 0
    fromEnum PackTypeEnd = 1
    fromEnum (AnotherPackType k :: Int
k) = Int
k

    toEnum :: Int -> PackType
toEnum 0 = PackType
PackTypeStart
    toEnum 1 = PackType
PackTypeEnd
    toEnum k :: Int
k = Int -> PackType
AnotherPackType Int
k

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

foreign import ccall "gtk_pack_type_get_type" c_gtk_pack_type_get_type :: 
    IO GType

instance BoxedEnum PackType where
    boxedEnumType :: PackType -> IO GType
boxedEnumType _ = IO GType
c_gtk_pack_type_get_type

-- Enum PackDirection
-- | Determines how widgets should be packed inside menubars
-- and menuitems contained in menubars.
data PackDirection = 
      PackDirectionLtr
    -- ^ Widgets are packed left-to-right
    | PackDirectionRtl
    -- ^ Widgets are packed right-to-left
    | PackDirectionTtb
    -- ^ Widgets are packed top-to-bottom
    | PackDirectionBtt
    -- ^ Widgets are packed bottom-to-top
    | AnotherPackDirection Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PackDirection -> ShowS
[PackDirection] -> ShowS
PackDirection -> String
(Int -> PackDirection -> ShowS)
-> (PackDirection -> String)
-> ([PackDirection] -> ShowS)
-> Show PackDirection
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PackDirection] -> ShowS
$cshowList :: [PackDirection] -> ShowS
show :: PackDirection -> String
$cshow :: PackDirection -> String
showsPrec :: Int -> PackDirection -> ShowS
$cshowsPrec :: Int -> PackDirection -> ShowS
Show, PackDirection -> PackDirection -> Bool
(PackDirection -> PackDirection -> Bool)
-> (PackDirection -> PackDirection -> Bool) -> Eq PackDirection
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PackDirection -> PackDirection -> Bool
$c/= :: PackDirection -> PackDirection -> Bool
== :: PackDirection -> PackDirection -> Bool
$c== :: PackDirection -> PackDirection -> Bool
Eq)

instance P.Enum PackDirection where
    fromEnum :: PackDirection -> Int
fromEnum PackDirectionLtr = 0
    fromEnum PackDirectionRtl = 1
    fromEnum PackDirectionTtb = 2
    fromEnum PackDirectionBtt = 3
    fromEnum (AnotherPackDirection k :: Int
k) = Int
k

    toEnum :: Int -> PackDirection
toEnum 0 = PackDirection
PackDirectionLtr
    toEnum 1 = PackDirection
PackDirectionRtl
    toEnum 2 = PackDirection
PackDirectionTtb
    toEnum 3 = PackDirection
PackDirectionBtt
    toEnum k :: Int
k = Int -> PackDirection
AnotherPackDirection Int
k

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

foreign import ccall "gtk_pack_direction_get_type" c_gtk_pack_direction_get_type :: 
    IO GType

instance BoxedEnum PackDirection where
    boxedEnumType :: PackDirection -> IO GType
boxedEnumType _ = IO GType
c_gtk_pack_direction_get_type

-- Enum Orientation
-- | Represents the orientation of widgets and other objects which can be switched
-- between horizontal and vertical orientation on the fly, like t'GI.Gtk.Objects.Toolbar.Toolbar' or
-- t'GI.Gtk.Objects.GesturePan.GesturePan'.
data Orientation = 
      OrientationHorizontal
    -- ^ The element is in horizontal orientation.
    | OrientationVertical
    -- ^ The element is in vertical orientation.
    | AnotherOrientation Int
    -- ^ Catch-all for unknown values
    deriving (Int -> Orientation -> ShowS
[Orientation] -> ShowS
Orientation -> String
(Int -> Orientation -> ShowS)
-> (Orientation -> String)
-> ([Orientation] -> ShowS)
-> Show Orientation
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Orientation] -> ShowS
$cshowList :: [Orientation] -> ShowS
show :: Orientation -> String
$cshow :: Orientation -> String
showsPrec :: Int -> Orientation -> ShowS
$cshowsPrec :: Int -> Orientation -> ShowS
Show, Orientation -> Orientation -> Bool
(Orientation -> Orientation -> Bool)
-> (Orientation -> Orientation -> Bool) -> Eq Orientation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Orientation -> Orientation -> Bool
$c/= :: Orientation -> Orientation -> Bool
== :: Orientation -> Orientation -> Bool
$c== :: Orientation -> Orientation -> Bool
Eq)

instance P.Enum Orientation where
    fromEnum :: Orientation -> Int
fromEnum OrientationHorizontal = 0
    fromEnum OrientationVertical = 1
    fromEnum (AnotherOrientation k :: Int
k) = Int
k

    toEnum :: Int -> Orientation
toEnum 0 = Orientation
OrientationHorizontal
    toEnum 1 = Orientation
OrientationVertical
    toEnum k :: Int
k = Int -> Orientation
AnotherOrientation Int
k

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

foreign import ccall "gtk_orientation_get_type" c_gtk_orientation_get_type :: 
    IO GType

instance BoxedEnum Orientation where
    boxedEnumType :: Orientation -> IO GType
boxedEnumType _ = IO GType
c_gtk_orientation_get_type

-- Enum NumberUpLayout
-- | Used to determine the layout of pages on a sheet when printing
-- multiple pages per sheet.
data NumberUpLayout = 
      NumberUpLayoutLrtb
    -- ^ <<https://developer.gnome.org/gtk3/stable/layout-lrtb.png>>
    | NumberUpLayoutLrbt
    -- ^ <<https://developer.gnome.org/gtk3/stable/layout-lrbt.png>>
    | NumberUpLayoutRltb
    -- ^ <<https://developer.gnome.org/gtk3/stable/layout-rltb.png>>
    | NumberUpLayoutRlbt
    -- ^ <<https://developer.gnome.org/gtk3/stable/layout-rlbt.png>>
    | NumberUpLayoutTblr
    -- ^ <<https://developer.gnome.org/gtk3/stable/layout-tblr.png>>
    | NumberUpLayoutTbrl
    -- ^ <<https://developer.gnome.org/gtk3/stable/layout-tbrl.png>>
    | NumberUpLayoutBtlr
    -- ^ <<https://developer.gnome.org/gtk3/stable/layout-btlr.png>>
    | NumberUpLayoutBtrl
    -- ^ <<https://developer.gnome.org/gtk3/stable/layout-btrl.png>>
    | AnotherNumberUpLayout Int
    -- ^ Catch-all for unknown values
    deriving (Int -> NumberUpLayout -> ShowS
[NumberUpLayout] -> ShowS
NumberUpLayout -> String
(Int -> NumberUpLayout -> ShowS)
-> (NumberUpLayout -> String)
-> ([NumberUpLayout] -> ShowS)
-> Show NumberUpLayout
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NumberUpLayout] -> ShowS
$cshowList :: [NumberUpLayout] -> ShowS
show :: NumberUpLayout -> String
$cshow :: NumberUpLayout -> String
showsPrec :: Int -> NumberUpLayout -> ShowS
$cshowsPrec :: Int -> NumberUpLayout -> ShowS
Show, NumberUpLayout -> NumberUpLayout -> Bool
(NumberUpLayout -> NumberUpLayout -> Bool)
-> (NumberUpLayout -> NumberUpLayout -> Bool) -> Eq NumberUpLayout
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NumberUpLayout -> NumberUpLayout -> Bool
$c/= :: NumberUpLayout -> NumberUpLayout -> Bool
== :: NumberUpLayout -> NumberUpLayout -> Bool
$c== :: NumberUpLayout -> NumberUpLayout -> Bool
Eq)

instance P.Enum NumberUpLayout where
    fromEnum :: NumberUpLayout -> Int
fromEnum NumberUpLayoutLrtb = 0
    fromEnum NumberUpLayoutLrbt = 1
    fromEnum NumberUpLayoutRltb = 2
    fromEnum NumberUpLayoutRlbt = 3
    fromEnum NumberUpLayoutTblr = 4
    fromEnum NumberUpLayoutTbrl = 5
    fromEnum NumberUpLayoutBtlr = 6
    fromEnum NumberUpLayoutBtrl = 7
    fromEnum (AnotherNumberUpLayout k :: Int
k) = Int
k

    toEnum :: Int -> NumberUpLayout
toEnum 0 = NumberUpLayout
NumberUpLayoutLrtb
    toEnum 1 = NumberUpLayout
NumberUpLayoutLrbt
    toEnum 2 = NumberUpLayout
NumberUpLayoutRltb
    toEnum 3 = NumberUpLayout
NumberUpLayoutRlbt
    toEnum 4 = NumberUpLayout
NumberUpLayoutTblr
    toEnum 5 = NumberUpLayout
NumberUpLayoutTbrl
    toEnum 6 = NumberUpLayout
NumberUpLayoutBtlr
    toEnum 7 = NumberUpLayout
NumberUpLayoutBtrl
    toEnum k :: Int
k = Int -> NumberUpLayout
AnotherNumberUpLayout Int
k

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

foreign import ccall "gtk_number_up_layout_get_type" c_gtk_number_up_layout_get_type :: 
    IO GType

instance BoxedEnum NumberUpLayout where
    boxedEnumType :: NumberUpLayout -> IO GType
boxedEnumType _ = IO GType
c_gtk_number_up_layout_get_type

-- Enum NotebookTab
-- | /No description available in the introspection data./
data NotebookTab = 
      NotebookTabFirst
    -- ^ /No description available in the introspection data./
    | NotebookTabLast
    -- ^ /No description available in the introspection data./
    | AnotherNotebookTab Int
    -- ^ Catch-all for unknown values
    deriving (Int -> NotebookTab -> ShowS
[NotebookTab] -> ShowS
NotebookTab -> String
(Int -> NotebookTab -> ShowS)
-> (NotebookTab -> String)
-> ([NotebookTab] -> ShowS)
-> Show NotebookTab
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NotebookTab] -> ShowS
$cshowList :: [NotebookTab] -> ShowS
show :: NotebookTab -> String
$cshow :: NotebookTab -> String
showsPrec :: Int -> NotebookTab -> ShowS
$cshowsPrec :: Int -> NotebookTab -> ShowS
Show, NotebookTab -> NotebookTab -> Bool
(NotebookTab -> NotebookTab -> Bool)
-> (NotebookTab -> NotebookTab -> Bool) -> Eq NotebookTab
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NotebookTab -> NotebookTab -> Bool
$c/= :: NotebookTab -> NotebookTab -> Bool
== :: NotebookTab -> NotebookTab -> Bool
$c== :: NotebookTab -> NotebookTab -> Bool
Eq)

instance P.Enum NotebookTab where
    fromEnum :: NotebookTab -> Int
fromEnum NotebookTabFirst = 0
    fromEnum NotebookTabLast = 1
    fromEnum (AnotherNotebookTab k :: Int
k) = Int
k

    toEnum :: Int -> NotebookTab
toEnum 0 = NotebookTab
NotebookTabFirst
    toEnum 1 = NotebookTab
NotebookTabLast
    toEnum k :: Int
k = Int -> NotebookTab
AnotherNotebookTab Int
k

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

foreign import ccall "gtk_notebook_tab_get_type" c_gtk_notebook_tab_get_type :: 
    IO GType

instance BoxedEnum NotebookTab where
    boxedEnumType :: NotebookTab -> IO GType
boxedEnumType _ = IO GType
c_gtk_notebook_tab_get_type

-- Enum MovementStep
-- | /No description available in the introspection data./
data MovementStep = 
      MovementStepLogicalPositions
    -- ^ Move forward or back by graphemes
    | MovementStepVisualPositions
    -- ^ Move left or right by graphemes
    | MovementStepWords
    -- ^ Move forward or back by words
    | MovementStepDisplayLines
    -- ^ Move up or down lines (wrapped lines)
    | MovementStepDisplayLineEnds
    -- ^ Move to either end of a line
    | MovementStepParagraphs
    -- ^ Move up or down paragraphs (newline-ended lines)
    | MovementStepParagraphEnds
    -- ^ Move to either end of a paragraph
    | MovementStepPages
    -- ^ Move by pages
    | MovementStepBufferEnds
    -- ^ Move to ends of the buffer
    | MovementStepHorizontalPages
    -- ^ Move horizontally by pages
    | AnotherMovementStep Int
    -- ^ Catch-all for unknown values
    deriving (Int -> MovementStep -> ShowS
[MovementStep] -> ShowS
MovementStep -> String
(Int -> MovementStep -> ShowS)
-> (MovementStep -> String)
-> ([MovementStep] -> ShowS)
-> Show MovementStep
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MovementStep] -> ShowS
$cshowList :: [MovementStep] -> ShowS
show :: MovementStep -> String
$cshow :: MovementStep -> String
showsPrec :: Int -> MovementStep -> ShowS
$cshowsPrec :: Int -> MovementStep -> ShowS
Show, MovementStep -> MovementStep -> Bool
(MovementStep -> MovementStep -> Bool)
-> (MovementStep -> MovementStep -> Bool) -> Eq MovementStep
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MovementStep -> MovementStep -> Bool
$c/= :: MovementStep -> MovementStep -> Bool
== :: MovementStep -> MovementStep -> Bool
$c== :: MovementStep -> MovementStep -> Bool
Eq)

instance P.Enum MovementStep where
    fromEnum :: MovementStep -> Int
fromEnum MovementStepLogicalPositions = 0
    fromEnum MovementStepVisualPositions = 1
    fromEnum MovementStepWords = 2
    fromEnum MovementStepDisplayLines = 3
    fromEnum MovementStepDisplayLineEnds = 4
    fromEnum MovementStepParagraphs = 5
    fromEnum MovementStepParagraphEnds = 6
    fromEnum MovementStepPages = 7
    fromEnum MovementStepBufferEnds = 8
    fromEnum MovementStepHorizontalPages = 9
    fromEnum (AnotherMovementStep k :: Int
k) = Int
k

    toEnum :: Int -> MovementStep
toEnum 0 = MovementStep
MovementStepLogicalPositions
    toEnum 1 = MovementStep
MovementStepVisualPositions
    toEnum 2 = MovementStep
MovementStepWords
    toEnum 3 = MovementStep
MovementStepDisplayLines
    toEnum 4 = MovementStep
MovementStepDisplayLineEnds
    toEnum 5 = MovementStep
MovementStepParagraphs
    toEnum 6 = MovementStep
MovementStepParagraphEnds
    toEnum 7 = MovementStep
MovementStepPages
    toEnum 8 = MovementStep
MovementStepBufferEnds
    toEnum 9 = MovementStep
MovementStepHorizontalPages
    toEnum k :: Int
k = Int -> MovementStep
AnotherMovementStep Int
k

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

foreign import ccall "gtk_movement_step_get_type" c_gtk_movement_step_get_type :: 
    IO GType

instance BoxedEnum MovementStep where
    boxedEnumType :: MovementStep -> IO GType
boxedEnumType _ = IO GType
c_gtk_movement_step_get_type

-- Enum MessageType
-- | The type of message being displayed in the dialog.
data MessageType = 
      MessageTypeInfo
    -- ^ Informational message
    | MessageTypeWarning
    -- ^ Non-fatal warning message
    | MessageTypeQuestion
    -- ^ Question requiring a choice
    | MessageTypeError
    -- ^ Fatal error message
    | MessageTypeOther
    -- ^ None of the above
    | AnotherMessageType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> MessageType -> ShowS
[MessageType] -> ShowS
MessageType -> String
(Int -> MessageType -> ShowS)
-> (MessageType -> String)
-> ([MessageType] -> ShowS)
-> Show MessageType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MessageType] -> ShowS
$cshowList :: [MessageType] -> ShowS
show :: MessageType -> String
$cshow :: MessageType -> String
showsPrec :: Int -> MessageType -> ShowS
$cshowsPrec :: Int -> MessageType -> ShowS
Show, MessageType -> MessageType -> Bool
(MessageType -> MessageType -> Bool)
-> (MessageType -> MessageType -> Bool) -> Eq MessageType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MessageType -> MessageType -> Bool
$c/= :: MessageType -> MessageType -> Bool
== :: MessageType -> MessageType -> Bool
$c== :: MessageType -> MessageType -> Bool
Eq)

instance P.Enum MessageType where
    fromEnum :: MessageType -> Int
fromEnum MessageTypeInfo = 0
    fromEnum MessageTypeWarning = 1
    fromEnum MessageTypeQuestion = 2
    fromEnum MessageTypeError = 3
    fromEnum MessageTypeOther = 4
    fromEnum (AnotherMessageType k :: Int
k) = Int
k

    toEnum :: Int -> MessageType
toEnum 0 = MessageType
MessageTypeInfo
    toEnum 1 = MessageType
MessageTypeWarning
    toEnum 2 = MessageType
MessageTypeQuestion
    toEnum 3 = MessageType
MessageTypeError
    toEnum 4 = MessageType
MessageTypeOther
    toEnum k :: Int
k = Int -> MessageType
AnotherMessageType Int
k

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

foreign import ccall "gtk_message_type_get_type" c_gtk_message_type_get_type :: 
    IO GType

instance BoxedEnum MessageType where
    boxedEnumType :: MessageType -> IO GType
boxedEnumType _ = IO GType
c_gtk_message_type_get_type

-- Enum MenuDirectionType
-- | An enumeration representing directional movements within a menu.
data MenuDirectionType = 
      MenuDirectionTypeParent
    -- ^ To the parent menu shell
    | MenuDirectionTypeChild
    -- ^ To the submenu, if any, associated with the item
    | MenuDirectionTypeNext
    -- ^ To the next menu item
    | MenuDirectionTypePrev
    -- ^ To the previous menu item
    | AnotherMenuDirectionType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> MenuDirectionType -> ShowS
[MenuDirectionType] -> ShowS
MenuDirectionType -> String
(Int -> MenuDirectionType -> ShowS)
-> (MenuDirectionType -> String)
-> ([MenuDirectionType] -> ShowS)
-> Show MenuDirectionType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MenuDirectionType] -> ShowS
$cshowList :: [MenuDirectionType] -> ShowS
show :: MenuDirectionType -> String
$cshow :: MenuDirectionType -> String
showsPrec :: Int -> MenuDirectionType -> ShowS
$cshowsPrec :: Int -> MenuDirectionType -> ShowS
Show, MenuDirectionType -> MenuDirectionType -> Bool
(MenuDirectionType -> MenuDirectionType -> Bool)
-> (MenuDirectionType -> MenuDirectionType -> Bool)
-> Eq MenuDirectionType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MenuDirectionType -> MenuDirectionType -> Bool
$c/= :: MenuDirectionType -> MenuDirectionType -> Bool
== :: MenuDirectionType -> MenuDirectionType -> Bool
$c== :: MenuDirectionType -> MenuDirectionType -> Bool
Eq)

instance P.Enum MenuDirectionType where
    fromEnum :: MenuDirectionType -> Int
fromEnum MenuDirectionTypeParent = 0
    fromEnum MenuDirectionTypeChild = 1
    fromEnum MenuDirectionTypeNext = 2
    fromEnum MenuDirectionTypePrev = 3
    fromEnum (AnotherMenuDirectionType k :: Int
k) = Int
k

    toEnum :: Int -> MenuDirectionType
toEnum 0 = MenuDirectionType
MenuDirectionTypeParent
    toEnum 1 = MenuDirectionType
MenuDirectionTypeChild
    toEnum 2 = MenuDirectionType
MenuDirectionTypeNext
    toEnum 3 = MenuDirectionType
MenuDirectionTypePrev
    toEnum k :: Int
k = Int -> MenuDirectionType
AnotherMenuDirectionType Int
k

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

foreign import ccall "gtk_menu_direction_type_get_type" c_gtk_menu_direction_type_get_type :: 
    IO GType

instance BoxedEnum MenuDirectionType where
    boxedEnumType :: MenuDirectionType -> IO GType
boxedEnumType _ = IO GType
c_gtk_menu_direction_type_get_type

-- Enum License
-- | The type of license for an application.
-- 
-- This enumeration can be expanded at later date.
-- 
-- /Since: 3.0/
data License = 
      LicenseUnknown
    -- ^ No license specified
    | LicenseCustom
    -- ^ A license text is going to be specified by the
    --   developer
    | LicenseGpl20
    -- ^ The GNU General Public License, version 2.0 or later
    | LicenseGpl30
    -- ^ The GNU General Public License, version 3.0 or later
    | LicenseLgpl21
    -- ^ The GNU Lesser General Public License, version 2.1 or later
    | LicenseLgpl30
    -- ^ The GNU Lesser General Public License, version 3.0 or later
    | LicenseBsd
    -- ^ The BSD standard license
    | LicenseMitX11
    -- ^ The MIT\/X11 standard license
    | LicenseArtistic
    -- ^ The Artistic License, version 2.0
    | LicenseGpl20Only
    -- ^ The GNU General Public License, version 2.0 only. Since 3.12.
    | LicenseGpl30Only
    -- ^ The GNU General Public License, version 3.0 only. Since 3.12.
    | LicenseLgpl21Only
    -- ^ The GNU Lesser General Public License, version 2.1 only. Since 3.12.
    | LicenseLgpl30Only
    -- ^ The GNU Lesser General Public License, version 3.0 only. Since 3.12.
    | LicenseAgpl30
    -- ^ The GNU Affero General Public License, version 3.0 or later. Since: 3.22.
    | LicenseAgpl30Only
    -- ^ The GNU Affero General Public License, version 3.0 only. Since: 3.22.27.
    | AnotherLicense Int
    -- ^ Catch-all for unknown values
    deriving (Int -> License -> ShowS
[License] -> ShowS
License -> String
(Int -> License -> ShowS)
-> (License -> String) -> ([License] -> ShowS) -> Show License
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [License] -> ShowS
$cshowList :: [License] -> ShowS
show :: License -> String
$cshow :: License -> String
showsPrec :: Int -> License -> ShowS
$cshowsPrec :: Int -> License -> ShowS
Show, License -> License -> Bool
(License -> License -> Bool)
-> (License -> License -> Bool) -> Eq License
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: License -> License -> Bool
$c/= :: License -> License -> Bool
== :: License -> License -> Bool
$c== :: License -> License -> Bool
Eq)

instance P.Enum License where
    fromEnum :: License -> Int
fromEnum LicenseUnknown = 0
    fromEnum LicenseCustom = 1
    fromEnum LicenseGpl20 = 2
    fromEnum LicenseGpl30 = 3
    fromEnum LicenseLgpl21 = 4
    fromEnum LicenseLgpl30 = 5
    fromEnum LicenseBsd = 6
    fromEnum LicenseMitX11 = 7
    fromEnum LicenseArtistic = 8
    fromEnum LicenseGpl20Only = 9
    fromEnum LicenseGpl30Only = 10
    fromEnum LicenseLgpl21Only = 11
    fromEnum LicenseLgpl30Only = 12
    fromEnum LicenseAgpl30 = 13
    fromEnum LicenseAgpl30Only = 14
    fromEnum (AnotherLicense k :: Int
k) = Int
k

    toEnum :: Int -> License
toEnum 0 = License
LicenseUnknown
    toEnum 1 = License
LicenseCustom
    toEnum 2 = License
LicenseGpl20
    toEnum 3 = License
LicenseGpl30
    toEnum 4 = License
LicenseLgpl21
    toEnum 5 = License
LicenseLgpl30
    toEnum 6 = License
LicenseBsd
    toEnum 7 = License
LicenseMitX11
    toEnum 8 = License
LicenseArtistic
    toEnum 9 = License
LicenseGpl20Only
    toEnum 10 = License
LicenseGpl30Only
    toEnum 11 = License
LicenseLgpl21Only
    toEnum 12 = License
LicenseLgpl30Only
    toEnum 13 = License
LicenseAgpl30
    toEnum 14 = License
LicenseAgpl30Only
    toEnum k :: Int
k = Int -> License
AnotherLicense Int
k

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

foreign import ccall "gtk_license_get_type" c_gtk_license_get_type :: 
    IO GType

instance BoxedEnum License where
    boxedEnumType :: License -> IO GType
boxedEnumType _ = IO GType
c_gtk_license_get_type

-- Enum LevelBarMode
-- | Describes how t'GI.Gtk.Objects.LevelBar.LevelBar' contents should be rendered.
-- Note that this enumeration could be extended with additional modes
-- in the future.
-- 
-- /Since: 3.6/
data LevelBarMode = 
      LevelBarModeContinuous
    -- ^ the bar has a continuous mode
    | LevelBarModeDiscrete
    -- ^ the bar has a discrete mode
    | AnotherLevelBarMode Int
    -- ^ Catch-all for unknown values
    deriving (Int -> LevelBarMode -> ShowS
[LevelBarMode] -> ShowS
LevelBarMode -> String
(Int -> LevelBarMode -> ShowS)
-> (LevelBarMode -> String)
-> ([LevelBarMode] -> ShowS)
-> Show LevelBarMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [LevelBarMode] -> ShowS
$cshowList :: [LevelBarMode] -> ShowS
show :: LevelBarMode -> String
$cshow :: LevelBarMode -> String
showsPrec :: Int -> LevelBarMode -> ShowS
$cshowsPrec :: Int -> LevelBarMode -> ShowS
Show, LevelBarMode -> LevelBarMode -> Bool
(LevelBarMode -> LevelBarMode -> Bool)
-> (LevelBarMode -> LevelBarMode -> Bool) -> Eq LevelBarMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: LevelBarMode -> LevelBarMode -> Bool
$c/= :: LevelBarMode -> LevelBarMode -> Bool
== :: LevelBarMode -> LevelBarMode -> Bool
$c== :: LevelBarMode -> LevelBarMode -> Bool
Eq)

instance P.Enum LevelBarMode where
    fromEnum :: LevelBarMode -> Int
fromEnum LevelBarModeContinuous = 0
    fromEnum LevelBarModeDiscrete = 1
    fromEnum (AnotherLevelBarMode k :: Int
k) = Int
k

    toEnum :: Int -> LevelBarMode
toEnum 0 = LevelBarMode
LevelBarModeContinuous
    toEnum 1 = LevelBarMode
LevelBarModeDiscrete
    toEnum k :: Int
k = Int -> LevelBarMode
AnotherLevelBarMode Int
k

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

foreign import ccall "gtk_level_bar_mode_get_type" c_gtk_level_bar_mode_get_type :: 
    IO GType

instance BoxedEnum LevelBarMode where
    boxedEnumType :: LevelBarMode -> IO GType
boxedEnumType _ = IO GType
c_gtk_level_bar_mode_get_type

-- Enum Justification
-- | Used for justifying the text inside a t'GI.Gtk.Objects.Label.Label' widget. (See also
-- t'GI.Gtk.Objects.Alignment.Alignment').
data Justification = 
      JustificationLeft
    -- ^ The text is placed at the left edge of the label.
    | JustificationRight
    -- ^ The text is placed at the right edge of the label.
    | JustificationCenter
    -- ^ The text is placed in the center of the label.
    | JustificationFill
    -- ^ The text is placed is distributed across the label.
    | AnotherJustification Int
    -- ^ Catch-all for unknown values
    deriving (Int -> Justification -> ShowS
[Justification] -> ShowS
Justification -> String
(Int -> Justification -> ShowS)
-> (Justification -> String)
-> ([Justification] -> ShowS)
-> Show Justification
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Justification] -> ShowS
$cshowList :: [Justification] -> ShowS
show :: Justification -> String
$cshow :: Justification -> String
showsPrec :: Int -> Justification -> ShowS
$cshowsPrec :: Int -> Justification -> ShowS
Show, Justification -> Justification -> Bool
(Justification -> Justification -> Bool)
-> (Justification -> Justification -> Bool) -> Eq Justification
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Justification -> Justification -> Bool
$c/= :: Justification -> Justification -> Bool
== :: Justification -> Justification -> Bool
$c== :: Justification -> Justification -> Bool
Eq)

instance P.Enum Justification where
    fromEnum :: Justification -> Int
fromEnum JustificationLeft = 0
    fromEnum JustificationRight = 1
    fromEnum JustificationCenter = 2
    fromEnum JustificationFill = 3
    fromEnum (AnotherJustification k :: Int
k) = Int
k

    toEnum :: Int -> Justification
toEnum 0 = Justification
JustificationLeft
    toEnum 1 = Justification
JustificationRight
    toEnum 2 = Justification
JustificationCenter
    toEnum 3 = Justification
JustificationFill
    toEnum k :: Int
k = Int -> Justification
AnotherJustification Int
k

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

foreign import ccall "gtk_justification_get_type" c_gtk_justification_get_type :: 
    IO GType

instance BoxedEnum Justification where
    boxedEnumType :: Justification -> IO GType
boxedEnumType _ = IO GType
c_gtk_justification_get_type

-- Enum InputPurpose
-- | Describes primary purpose of the input widget. This information is
-- useful for on-screen keyboards and similar input methods to decide
-- which keys should be presented to the user.
-- 
-- Note that the purpose is not meant to impose a totally strict rule
-- about allowed characters, and does not replace input validation.
-- It is fine for an on-screen keyboard to let the user override the
-- character set restriction that is expressed by the purpose. The
-- application is expected to validate the entry contents, even if
-- it specified a purpose.
-- 
-- The difference between /@gTKINPUTPURPOSEDIGITS@/ and
-- /@gTKINPUTPURPOSENUMBER@/ is that the former accepts only digits
-- while the latter also some punctuation (like commas or points, plus,
-- minus) and “e” or “E” as in 3.14E+000.
-- 
-- This enumeration may be extended in the future; input methods should
-- interpret unknown values as “free form”.
-- 
-- /Since: 3.6/
data InputPurpose = 
      InputPurposeFreeForm
    -- ^ Allow any character
    | InputPurposeAlpha
    -- ^ Allow only alphabetic characters
    | InputPurposeDigits
    -- ^ Allow only digits
    | InputPurposeNumber
    -- ^ Edited field expects numbers
    | InputPurposePhone
    -- ^ Edited field expects phone number
    | InputPurposeUrl
    -- ^ Edited field expects URL
    | InputPurposeEmail
    -- ^ Edited field expects email address
    | InputPurposeName
    -- ^ Edited field expects the name of a person
    | InputPurposePassword
    -- ^ Like /@gTKINPUTPURPOSEFREEFORM@/, but characters are hidden
    | InputPurposePin
    -- ^ Like /@gTKINPUTPURPOSEDIGITS@/, but characters are hidden
    | AnotherInputPurpose Int
    -- ^ Catch-all for unknown values
    deriving (Int -> InputPurpose -> ShowS
[InputPurpose] -> ShowS
InputPurpose -> String
(Int -> InputPurpose -> ShowS)
-> (InputPurpose -> String)
-> ([InputPurpose] -> ShowS)
-> Show InputPurpose
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [InputPurpose] -> ShowS
$cshowList :: [InputPurpose] -> ShowS
show :: InputPurpose -> String
$cshow :: InputPurpose -> String
showsPrec :: Int -> InputPurpose -> ShowS
$cshowsPrec :: Int -> InputPurpose -> ShowS
Show, InputPurpose -> InputPurpose -> Bool
(InputPurpose -> InputPurpose -> Bool)
-> (InputPurpose -> InputPurpose -> Bool) -> Eq InputPurpose
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: InputPurpose -> InputPurpose -> Bool
$c/= :: InputPurpose -> InputPurpose -> Bool
== :: InputPurpose -> InputPurpose -> Bool
$c== :: InputPurpose -> InputPurpose -> Bool
Eq)

instance P.Enum InputPurpose where
    fromEnum :: InputPurpose -> Int
fromEnum InputPurposeFreeForm = 0
    fromEnum InputPurposeAlpha = 1
    fromEnum InputPurposeDigits = 2
    fromEnum InputPurposeNumber = 3
    fromEnum InputPurposePhone = 4
    fromEnum InputPurposeUrl = 5
    fromEnum InputPurposeEmail = 6
    fromEnum InputPurposeName = 7
    fromEnum InputPurposePassword = 8
    fromEnum InputPurposePin = 9
    fromEnum (AnotherInputPurpose k :: Int
k) = Int
k

    toEnum :: Int -> InputPurpose
toEnum 0 = InputPurpose
InputPurposeFreeForm
    toEnum 1 = InputPurpose
InputPurposeAlpha
    toEnum 2 = InputPurpose
InputPurposeDigits
    toEnum 3 = InputPurpose
InputPurposeNumber
    toEnum 4 = InputPurpose
InputPurposePhone
    toEnum 5 = InputPurpose
InputPurposeUrl
    toEnum 6 = InputPurpose
InputPurposeEmail
    toEnum 7 = InputPurpose
InputPurposeName
    toEnum 8 = InputPurpose
InputPurposePassword
    toEnum 9 = InputPurpose
InputPurposePin
    toEnum k :: Int
k = Int -> InputPurpose
AnotherInputPurpose Int
k

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

foreign import ccall "gtk_input_purpose_get_type" c_gtk_input_purpose_get_type :: 
    IO GType

instance BoxedEnum InputPurpose where
    boxedEnumType :: InputPurpose -> IO GType
boxedEnumType _ = IO GType
c_gtk_input_purpose_get_type

-- Enum ImageType
-- | Describes the image data representation used by a t'GI.Gtk.Objects.Image.Image'. If you
-- want to get the image from the widget, you can only get the
-- currently-stored representation. e.g.  if the
-- 'GI.Gtk.Objects.Image.imageGetStorageType' returns @/GTK_IMAGE_PIXBUF/@, then you can
-- call 'GI.Gtk.Objects.Image.imageGetPixbuf' but not 'GI.Gtk.Objects.Image.imageGetStock'.  For empty
-- images, you can request any storage type (call any of the \"get\"
-- functions), but they will all return 'P.Nothing' values.
data ImageType = 
      ImageTypeEmpty
    -- ^ there is no image displayed by the widget
    | ImageTypePixbuf
    -- ^ the widget contains a t'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf'
    | ImageTypeStock
    -- ^ the widget contains a [stock item name][gtkstock]
    | ImageTypeIconSet
    -- ^ the widget contains a t'GI.Gtk.Structs.IconSet.IconSet'
    | ImageTypeAnimation
    -- ^ the widget contains a t'GI.GdkPixbuf.Objects.PixbufAnimation.PixbufAnimation'
    | ImageTypeIconName
    -- ^ the widget contains a named icon.
    --  This image type was added in GTK+ 2.6
    | ImageTypeGicon
    -- ^ the widget contains a t'GI.Gio.Interfaces.Icon.Icon'.
    --  This image type was added in GTK+ 2.14
    | ImageTypeSurface
    -- ^ the widget contains a t'GI.Cairo.Structs.Surface.Surface'.
    --  This image type was added in GTK+ 3.10
    | AnotherImageType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ImageType -> ShowS
[ImageType] -> ShowS
ImageType -> String
(Int -> ImageType -> ShowS)
-> (ImageType -> String)
-> ([ImageType] -> ShowS)
-> Show ImageType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ImageType] -> ShowS
$cshowList :: [ImageType] -> ShowS
show :: ImageType -> String
$cshow :: ImageType -> String
showsPrec :: Int -> ImageType -> ShowS
$cshowsPrec :: Int -> ImageType -> ShowS
Show, ImageType -> ImageType -> Bool
(ImageType -> ImageType -> Bool)
-> (ImageType -> ImageType -> Bool) -> Eq ImageType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ImageType -> ImageType -> Bool
$c/= :: ImageType -> ImageType -> Bool
== :: ImageType -> ImageType -> Bool
$c== :: ImageType -> ImageType -> Bool
Eq)

instance P.Enum ImageType where
    fromEnum :: ImageType -> Int
fromEnum ImageTypeEmpty = 0
    fromEnum ImageTypePixbuf = 1
    fromEnum ImageTypeStock = 2
    fromEnum ImageTypeIconSet = 3
    fromEnum ImageTypeAnimation = 4
    fromEnum ImageTypeIconName = 5
    fromEnum ImageTypeGicon = 6
    fromEnum ImageTypeSurface = 7
    fromEnum (AnotherImageType k :: Int
k) = Int
k

    toEnum :: Int -> ImageType
toEnum 0 = ImageType
ImageTypeEmpty
    toEnum 1 = ImageType
ImageTypePixbuf
    toEnum 2 = ImageType
ImageTypeStock
    toEnum 3 = ImageType
ImageTypeIconSet
    toEnum 4 = ImageType
ImageTypeAnimation
    toEnum 5 = ImageType
ImageTypeIconName
    toEnum 6 = ImageType
ImageTypeGicon
    toEnum 7 = ImageType
ImageTypeSurface
    toEnum k :: Int
k = Int -> ImageType
AnotherImageType Int
k

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

foreign import ccall "gtk_image_type_get_type" c_gtk_image_type_get_type :: 
    IO GType

instance BoxedEnum ImageType where
    boxedEnumType :: ImageType -> IO GType
boxedEnumType _ = IO GType
c_gtk_image_type_get_type

-- Enum IconViewDropPosition
-- | An enum for determining where a dropped item goes.
data IconViewDropPosition = 
      IconViewDropPositionNoDrop
    -- ^ no drop possible
    | IconViewDropPositionDropInto
    -- ^ dropped item replaces the item
    | IconViewDropPositionDropLeft
    -- ^ droppped item is inserted to the left
    | IconViewDropPositionDropRight
    -- ^ dropped item is inserted to the right
    | IconViewDropPositionDropAbove
    -- ^ dropped item is inserted above
    | IconViewDropPositionDropBelow
    -- ^ dropped item is inserted below
    | AnotherIconViewDropPosition Int
    -- ^ Catch-all for unknown values
    deriving (Int -> IconViewDropPosition -> ShowS
[IconViewDropPosition] -> ShowS
IconViewDropPosition -> String
(Int -> IconViewDropPosition -> ShowS)
-> (IconViewDropPosition -> String)
-> ([IconViewDropPosition] -> ShowS)
-> Show IconViewDropPosition
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [IconViewDropPosition] -> ShowS
$cshowList :: [IconViewDropPosition] -> ShowS
show :: IconViewDropPosition -> String
$cshow :: IconViewDropPosition -> String
showsPrec :: Int -> IconViewDropPosition -> ShowS
$cshowsPrec :: Int -> IconViewDropPosition -> ShowS
Show, IconViewDropPosition -> IconViewDropPosition -> Bool
(IconViewDropPosition -> IconViewDropPosition -> Bool)
-> (IconViewDropPosition -> IconViewDropPosition -> Bool)
-> Eq IconViewDropPosition
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: IconViewDropPosition -> IconViewDropPosition -> Bool
$c/= :: IconViewDropPosition -> IconViewDropPosition -> Bool
== :: IconViewDropPosition -> IconViewDropPosition -> Bool
$c== :: IconViewDropPosition -> IconViewDropPosition -> Bool
Eq)

instance P.Enum IconViewDropPosition where
    fromEnum :: IconViewDropPosition -> Int
fromEnum IconViewDropPositionNoDrop = 0
    fromEnum IconViewDropPositionDropInto = 1
    fromEnum IconViewDropPositionDropLeft = 2
    fromEnum IconViewDropPositionDropRight = 3
    fromEnum IconViewDropPositionDropAbove = 4
    fromEnum IconViewDropPositionDropBelow = 5
    fromEnum (AnotherIconViewDropPosition k :: Int
k) = Int
k

    toEnum :: Int -> IconViewDropPosition
toEnum 0 = IconViewDropPosition
IconViewDropPositionNoDrop
    toEnum 1 = IconViewDropPosition
IconViewDropPositionDropInto
    toEnum 2 = IconViewDropPosition
IconViewDropPositionDropLeft
    toEnum 3 = IconViewDropPosition
IconViewDropPositionDropRight
    toEnum 4 = IconViewDropPosition
IconViewDropPositionDropAbove
    toEnum 5 = IconViewDropPosition
IconViewDropPositionDropBelow
    toEnum k :: Int
k = Int -> IconViewDropPosition
AnotherIconViewDropPosition Int
k

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

foreign import ccall "gtk_icon_view_drop_position_get_type" c_gtk_icon_view_drop_position_get_type :: 
    IO GType

instance BoxedEnum IconViewDropPosition where
    boxedEnumType :: IconViewDropPosition -> IO GType
boxedEnumType _ = IO GType
c_gtk_icon_view_drop_position_get_type

-- Enum IconThemeError
-- | Error codes for GtkIconTheme operations.
data IconThemeError = 
      IconThemeErrorNotFound
    -- ^ The icon specified does not exist in the theme
    | IconThemeErrorFailed
    -- ^ An unspecified error occurred.
    | AnotherIconThemeError Int
    -- ^ Catch-all for unknown values
    deriving (Int -> IconThemeError -> ShowS
[IconThemeError] -> ShowS
IconThemeError -> String
(Int -> IconThemeError -> ShowS)
-> (IconThemeError -> String)
-> ([IconThemeError] -> ShowS)
-> Show IconThemeError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [IconThemeError] -> ShowS
$cshowList :: [IconThemeError] -> ShowS
show :: IconThemeError -> String
$cshow :: IconThemeError -> String
showsPrec :: Int -> IconThemeError -> ShowS
$cshowsPrec :: Int -> IconThemeError -> ShowS
Show, IconThemeError -> IconThemeError -> Bool
(IconThemeError -> IconThemeError -> Bool)
-> (IconThemeError -> IconThemeError -> Bool) -> Eq IconThemeError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: IconThemeError -> IconThemeError -> Bool
$c/= :: IconThemeError -> IconThemeError -> Bool
== :: IconThemeError -> IconThemeError -> Bool
$c== :: IconThemeError -> IconThemeError -> Bool
Eq)

instance P.Enum IconThemeError where
    fromEnum :: IconThemeError -> Int
fromEnum IconThemeErrorNotFound = 0
    fromEnum IconThemeErrorFailed = 1
    fromEnum (AnotherIconThemeError k :: Int
k) = Int
k

    toEnum :: Int -> IconThemeError
toEnum 0 = IconThemeError
IconThemeErrorNotFound
    toEnum 1 = IconThemeError
IconThemeErrorFailed
    toEnum k :: Int
k = Int -> IconThemeError
AnotherIconThemeError Int
k

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

instance GErrorClass IconThemeError where
    gerrorClassDomain :: IconThemeError -> Text
gerrorClassDomain _ = "gtk-icon-theme-error-quark"

-- | Catch exceptions of type `IconThemeError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
catchIconThemeError ::
    IO a ->
    (IconThemeError -> GErrorMessage -> IO a) ->
    IO a
catchIconThemeError :: IO a -> (IconThemeError -> Text -> IO a) -> IO a
catchIconThemeError = IO a -> (IconThemeError -> Text -> IO a) -> IO a
forall err a.
GErrorClass err =>
IO a -> (err -> Text -> IO a) -> IO a
catchGErrorJustDomain

-- | Handle exceptions of type `IconThemeError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
handleIconThemeError ::
    (IconThemeError -> GErrorMessage -> IO a) ->
    IO a ->
    IO a
handleIconThemeError :: (IconThemeError -> Text -> IO a) -> IO a -> IO a
handleIconThemeError = (IconThemeError -> Text -> IO a) -> IO a -> IO a
forall err a.
GErrorClass err =>
(err -> Text -> IO a) -> IO a -> IO a
handleGErrorJustDomain

foreign import ccall "gtk_icon_theme_error_get_type" c_gtk_icon_theme_error_get_type :: 
    IO GType

instance BoxedEnum IconThemeError where
    boxedEnumType :: IconThemeError -> IO GType
boxedEnumType _ = IO GType
c_gtk_icon_theme_error_get_type

-- Enum IconSize
-- | Built-in stock icon sizes.
data IconSize = 
      IconSizeInvalid
    -- ^ Invalid size.
    | IconSizeMenu
    -- ^ Size appropriate for menus (16px).
    | IconSizeSmallToolbar
    -- ^ Size appropriate for small toolbars (16px).
    | IconSizeLargeToolbar
    -- ^ Size appropriate for large toolbars (24px)
    | IconSizeButton
    -- ^ Size appropriate for buttons (16px)
    | IconSizeDnd
    -- ^ Size appropriate for drag and drop (32px)
    | IconSizeDialog
    -- ^ Size appropriate for dialogs (48px)
    | AnotherIconSize Int
    -- ^ Catch-all for unknown values
    deriving (Int -> IconSize -> ShowS
[IconSize] -> ShowS
IconSize -> String
(Int -> IconSize -> ShowS)
-> (IconSize -> String) -> ([IconSize] -> ShowS) -> Show IconSize
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [IconSize] -> ShowS
$cshowList :: [IconSize] -> ShowS
show :: IconSize -> String
$cshow :: IconSize -> String
showsPrec :: Int -> IconSize -> ShowS
$cshowsPrec :: Int -> IconSize -> ShowS
Show, IconSize -> IconSize -> Bool
(IconSize -> IconSize -> Bool)
-> (IconSize -> IconSize -> Bool) -> Eq IconSize
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: IconSize -> IconSize -> Bool
$c/= :: IconSize -> IconSize -> Bool
== :: IconSize -> IconSize -> Bool
$c== :: IconSize -> IconSize -> Bool
Eq)

instance P.Enum IconSize where
    fromEnum :: IconSize -> Int
fromEnum IconSizeInvalid = 0
    fromEnum IconSizeMenu = 1
    fromEnum IconSizeSmallToolbar = 2
    fromEnum IconSizeLargeToolbar = 3
    fromEnum IconSizeButton = 4
    fromEnum IconSizeDnd = 5
    fromEnum IconSizeDialog = 6
    fromEnum (AnotherIconSize k :: Int
k) = Int
k

    toEnum :: Int -> IconSize
toEnum 0 = IconSize
IconSizeInvalid
    toEnum 1 = IconSize
IconSizeMenu
    toEnum 2 = IconSize
IconSizeSmallToolbar
    toEnum 3 = IconSize
IconSizeLargeToolbar
    toEnum 4 = IconSize
IconSizeButton
    toEnum 5 = IconSize
IconSizeDnd
    toEnum 6 = IconSize
IconSizeDialog
    toEnum k :: Int
k = Int -> IconSize
AnotherIconSize Int
k

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

foreign import ccall "gtk_icon_size_get_type" c_gtk_icon_size_get_type :: 
    IO GType

instance BoxedEnum IconSize where
    boxedEnumType :: IconSize -> IO GType
boxedEnumType _ = IO GType
c_gtk_icon_size_get_type

-- Enum IMStatusStyle
{-# DEPRECATED IMStatusStyle ["(Since version 3.10)"] #-}
-- | Style for input method status. See also
-- t'GI.Gtk.Objects.Settings.Settings':@/gtk-im-status-style/@
data IMStatusStyle = 
      IMStatusStyleNothing
    -- ^ Deprecated
    | IMStatusStyleCallback
    -- ^ Deprecated
    | IMStatusStyleNone
    -- ^ Deprecated
    | AnotherIMStatusStyle Int
    -- ^ Catch-all for unknown values
    deriving (Int -> IMStatusStyle -> ShowS
[IMStatusStyle] -> ShowS
IMStatusStyle -> String
(Int -> IMStatusStyle -> ShowS)
-> (IMStatusStyle -> String)
-> ([IMStatusStyle] -> ShowS)
-> Show IMStatusStyle
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [IMStatusStyle] -> ShowS
$cshowList :: [IMStatusStyle] -> ShowS
show :: IMStatusStyle -> String
$cshow :: IMStatusStyle -> String
showsPrec :: Int -> IMStatusStyle -> ShowS
$cshowsPrec :: Int -> IMStatusStyle -> ShowS
Show, IMStatusStyle -> IMStatusStyle -> Bool
(IMStatusStyle -> IMStatusStyle -> Bool)
-> (IMStatusStyle -> IMStatusStyle -> Bool) -> Eq IMStatusStyle
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: IMStatusStyle -> IMStatusStyle -> Bool
$c/= :: IMStatusStyle -> IMStatusStyle -> Bool
== :: IMStatusStyle -> IMStatusStyle -> Bool
$c== :: IMStatusStyle -> IMStatusStyle -> Bool
Eq)

instance P.Enum IMStatusStyle where
    fromEnum :: IMStatusStyle -> Int
fromEnum IMStatusStyleNothing = 0
    fromEnum IMStatusStyleCallback = 1
    fromEnum IMStatusStyleNone = 2
    fromEnum (AnotherIMStatusStyle k :: Int
k) = Int
k

    toEnum :: Int -> IMStatusStyle
toEnum 0 = IMStatusStyle
IMStatusStyleNothing
    toEnum 1 = IMStatusStyle
IMStatusStyleCallback
    toEnum 2 = IMStatusStyle
IMStatusStyleNone
    toEnum k :: Int
k = Int -> IMStatusStyle
AnotherIMStatusStyle Int
k

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

foreign import ccall "gtk_im_status_style_get_type" c_gtk_im_status_style_get_type :: 
    IO GType

instance BoxedEnum IMStatusStyle where
    boxedEnumType :: IMStatusStyle -> IO GType
boxedEnumType _ = IO GType
c_gtk_im_status_style_get_type

-- Enum IMPreeditStyle
{-# DEPRECATED IMPreeditStyle ["(Since version 3.10)"] #-}
-- | Style for input method preedit. See also
-- t'GI.Gtk.Objects.Settings.Settings':@/gtk-im-preedit-style/@
data IMPreeditStyle = 
      IMPreeditStyleNothing
    -- ^ Deprecated
    | IMPreeditStyleCallback
    -- ^ Deprecated
    | IMPreeditStyleNone
    -- ^ Deprecated
    | AnotherIMPreeditStyle Int
    -- ^ Catch-all for unknown values
    deriving (Int -> IMPreeditStyle -> ShowS
[IMPreeditStyle] -> ShowS
IMPreeditStyle -> String
(Int -> IMPreeditStyle -> ShowS)
-> (IMPreeditStyle -> String)
-> ([IMPreeditStyle] -> ShowS)
-> Show IMPreeditStyle
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [IMPreeditStyle] -> ShowS
$cshowList :: [IMPreeditStyle] -> ShowS
show :: IMPreeditStyle -> String
$cshow :: IMPreeditStyle -> String
showsPrec :: Int -> IMPreeditStyle -> ShowS
$cshowsPrec :: Int -> IMPreeditStyle -> ShowS
Show, IMPreeditStyle -> IMPreeditStyle -> Bool
(IMPreeditStyle -> IMPreeditStyle -> Bool)
-> (IMPreeditStyle -> IMPreeditStyle -> Bool) -> Eq IMPreeditStyle
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: IMPreeditStyle -> IMPreeditStyle -> Bool
$c/= :: IMPreeditStyle -> IMPreeditStyle -> Bool
== :: IMPreeditStyle -> IMPreeditStyle -> Bool
$c== :: IMPreeditStyle -> IMPreeditStyle -> Bool
Eq)

instance P.Enum IMPreeditStyle where
    fromEnum :: IMPreeditStyle -> Int
fromEnum IMPreeditStyleNothing = 0
    fromEnum IMPreeditStyleCallback = 1
    fromEnum IMPreeditStyleNone = 2
    fromEnum (AnotherIMPreeditStyle k :: Int
k) = Int
k

    toEnum :: Int -> IMPreeditStyle
toEnum 0 = IMPreeditStyle
IMPreeditStyleNothing
    toEnum 1 = IMPreeditStyle
IMPreeditStyleCallback
    toEnum 2 = IMPreeditStyle
IMPreeditStyleNone
    toEnum k :: Int
k = Int -> IMPreeditStyle
AnotherIMPreeditStyle Int
k

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

foreign import ccall "gtk_im_preedit_style_get_type" c_gtk_im_preedit_style_get_type :: 
    IO GType

instance BoxedEnum IMPreeditStyle where
    boxedEnumType :: IMPreeditStyle -> IO GType
boxedEnumType _ = IO GType
c_gtk_im_preedit_style_get_type

-- Enum FileChooserError
-- | These identify the various errors that can occur while calling
-- t'GI.Gtk.Interfaces.FileChooser.FileChooser' functions.
data FileChooserError = 
      FileChooserErrorNonexistent
    -- ^ Indicates that a file does not exist.
    | FileChooserErrorBadFilename
    -- ^ Indicates a malformed filename.
    | FileChooserErrorAlreadyExists
    -- ^ Indicates a duplicate path (e.g. when
    --  adding a bookmark).
    | FileChooserErrorIncompleteHostname
    -- ^ Indicates an incomplete hostname (e.g. \"http:\/\/foo\" without a slash after that).
    | AnotherFileChooserError Int
    -- ^ Catch-all for unknown values
    deriving (Int -> FileChooserError -> ShowS
[FileChooserError] -> ShowS
FileChooserError -> String
(Int -> FileChooserError -> ShowS)
-> (FileChooserError -> String)
-> ([FileChooserError] -> ShowS)
-> Show FileChooserError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FileChooserError] -> ShowS
$cshowList :: [FileChooserError] -> ShowS
show :: FileChooserError -> String
$cshow :: FileChooserError -> String
showsPrec :: Int -> FileChooserError -> ShowS
$cshowsPrec :: Int -> FileChooserError -> ShowS
Show, FileChooserError -> FileChooserError -> Bool
(FileChooserError -> FileChooserError -> Bool)
-> (FileChooserError -> FileChooserError -> Bool)
-> Eq FileChooserError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FileChooserError -> FileChooserError -> Bool
$c/= :: FileChooserError -> FileChooserError -> Bool
== :: FileChooserError -> FileChooserError -> Bool
$c== :: FileChooserError -> FileChooserError -> Bool
Eq)

instance P.Enum FileChooserError where
    fromEnum :: FileChooserError -> Int
fromEnum FileChooserErrorNonexistent = 0
    fromEnum FileChooserErrorBadFilename = 1
    fromEnum FileChooserErrorAlreadyExists = 2
    fromEnum FileChooserErrorIncompleteHostname = 3
    fromEnum (AnotherFileChooserError k :: Int
k) = Int
k

    toEnum :: Int -> FileChooserError
toEnum 0 = FileChooserError
FileChooserErrorNonexistent
    toEnum 1 = FileChooserError
FileChooserErrorBadFilename
    toEnum 2 = FileChooserError
FileChooserErrorAlreadyExists
    toEnum 3 = FileChooserError
FileChooserErrorIncompleteHostname
    toEnum k :: Int
k = Int -> FileChooserError
AnotherFileChooserError Int
k

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

instance GErrorClass FileChooserError where
    gerrorClassDomain :: FileChooserError -> Text
gerrorClassDomain _ = "gtk-file-chooser-error-quark"

-- | Catch exceptions of type `FileChooserError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
catchFileChooserError ::
    IO a ->
    (FileChooserError -> GErrorMessage -> IO a) ->
    IO a
catchFileChooserError :: IO a -> (FileChooserError -> Text -> IO a) -> IO a
catchFileChooserError = IO a -> (FileChooserError -> Text -> IO a) -> IO a
forall err a.
GErrorClass err =>
IO a -> (err -> Text -> IO a) -> IO a
catchGErrorJustDomain

-- | Handle exceptions of type `FileChooserError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
handleFileChooserError ::
    (FileChooserError -> GErrorMessage -> IO a) ->
    IO a ->
    IO a
handleFileChooserError :: (FileChooserError -> Text -> IO a) -> IO a -> IO a
handleFileChooserError = (FileChooserError -> Text -> IO a) -> IO a -> IO a
forall err a.
GErrorClass err =>
(err -> Text -> IO a) -> IO a -> IO a
handleGErrorJustDomain

foreign import ccall "gtk_file_chooser_error_get_type" c_gtk_file_chooser_error_get_type :: 
    IO GType

instance BoxedEnum FileChooserError where
    boxedEnumType :: FileChooserError -> IO GType
boxedEnumType _ = IO GType
c_gtk_file_chooser_error_get_type

-- Enum FileChooserConfirmation
-- | Used as a return value of handlers for the
-- [confirmOverwrite]("GI.Gtk.Interfaces.FileChooser#signal:confirmOverwrite") signal of a t'GI.Gtk.Interfaces.FileChooser.FileChooser'. This
-- value determines whether the file chooser will present the stock
-- confirmation dialog, accept the user’s choice of a filename, or
-- let the user choose another filename.
-- 
-- /Since: 2.8/
data FileChooserConfirmation = 
      FileChooserConfirmationConfirm
    -- ^ The file chooser will present
    --  its stock dialog to confirm about overwriting an existing file.
    | FileChooserConfirmationAcceptFilename
    -- ^ The file chooser will
    --  terminate and accept the user’s choice of a file name.
    | FileChooserConfirmationSelectAgain
    -- ^ The file chooser will
    --  continue running, so as to let the user select another file name.
    | AnotherFileChooserConfirmation Int
    -- ^ Catch-all for unknown values
    deriving (Int -> FileChooserConfirmation -> ShowS
[FileChooserConfirmation] -> ShowS
FileChooserConfirmation -> String
(Int -> FileChooserConfirmation -> ShowS)
-> (FileChooserConfirmation -> String)
-> ([FileChooserConfirmation] -> ShowS)
-> Show FileChooserConfirmation
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FileChooserConfirmation] -> ShowS
$cshowList :: [FileChooserConfirmation] -> ShowS
show :: FileChooserConfirmation -> String
$cshow :: FileChooserConfirmation -> String
showsPrec :: Int -> FileChooserConfirmation -> ShowS
$cshowsPrec :: Int -> FileChooserConfirmation -> ShowS
Show, FileChooserConfirmation -> FileChooserConfirmation -> Bool
(FileChooserConfirmation -> FileChooserConfirmation -> Bool)
-> (FileChooserConfirmation -> FileChooserConfirmation -> Bool)
-> Eq FileChooserConfirmation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FileChooserConfirmation -> FileChooserConfirmation -> Bool
$c/= :: FileChooserConfirmation -> FileChooserConfirmation -> Bool
== :: FileChooserConfirmation -> FileChooserConfirmation -> Bool
$c== :: FileChooserConfirmation -> FileChooserConfirmation -> Bool
Eq)

instance P.Enum FileChooserConfirmation where
    fromEnum :: FileChooserConfirmation -> Int
fromEnum FileChooserConfirmationConfirm = 0
    fromEnum FileChooserConfirmationAcceptFilename = 1
    fromEnum FileChooserConfirmationSelectAgain = 2
    fromEnum (AnotherFileChooserConfirmation k :: Int
k) = Int
k

    toEnum :: Int -> FileChooserConfirmation
toEnum 0 = FileChooserConfirmation
FileChooserConfirmationConfirm
    toEnum 1 = FileChooserConfirmation
FileChooserConfirmationAcceptFilename
    toEnum 2 = FileChooserConfirmation
FileChooserConfirmationSelectAgain
    toEnum k :: Int
k = Int -> FileChooserConfirmation
AnotherFileChooserConfirmation Int
k

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

foreign import ccall "gtk_file_chooser_confirmation_get_type" c_gtk_file_chooser_confirmation_get_type :: 
    IO GType

instance BoxedEnum FileChooserConfirmation where
    boxedEnumType :: FileChooserConfirmation -> IO GType
boxedEnumType _ = IO GType
c_gtk_file_chooser_confirmation_get_type

-- Enum FileChooserAction
-- | Describes whether a t'GI.Gtk.Interfaces.FileChooser.FileChooser' is being used to open existing files
-- or to save to a possibly new file.
data FileChooserAction = 
      FileChooserActionOpen
    -- ^ Indicates open mode.  The file chooser
    --  will only let the user pick an existing file.
    | FileChooserActionSave
    -- ^ Indicates save mode.  The file chooser
    --  will let the user pick an existing file, or type in a new
    --  filename.
    | FileChooserActionSelectFolder
    -- ^ Indicates an Open mode for
    --  selecting folders.  The file chooser will let the user pick an
    --  existing folder.
    | FileChooserActionCreateFolder
    -- ^ Indicates a mode for creating a
    --  new folder.  The file chooser will let the user name an existing or
    --  new folder.
    | AnotherFileChooserAction Int
    -- ^ Catch-all for unknown values
    deriving (Int -> FileChooserAction -> ShowS
[FileChooserAction] -> ShowS
FileChooserAction -> String
(Int -> FileChooserAction -> ShowS)
-> (FileChooserAction -> String)
-> ([FileChooserAction] -> ShowS)
-> Show FileChooserAction
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FileChooserAction] -> ShowS
$cshowList :: [FileChooserAction] -> ShowS
show :: FileChooserAction -> String
$cshow :: FileChooserAction -> String
showsPrec :: Int -> FileChooserAction -> ShowS
$cshowsPrec :: Int -> FileChooserAction -> ShowS
Show, FileChooserAction -> FileChooserAction -> Bool
(FileChooserAction -> FileChooserAction -> Bool)
-> (FileChooserAction -> FileChooserAction -> Bool)
-> Eq FileChooserAction
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FileChooserAction -> FileChooserAction -> Bool
$c/= :: FileChooserAction -> FileChooserAction -> Bool
== :: FileChooserAction -> FileChooserAction -> Bool
$c== :: FileChooserAction -> FileChooserAction -> Bool
Eq)

instance P.Enum FileChooserAction where
    fromEnum :: FileChooserAction -> Int
fromEnum FileChooserActionOpen = 0
    fromEnum FileChooserActionSave = 1
    fromEnum FileChooserActionSelectFolder = 2
    fromEnum FileChooserActionCreateFolder = 3
    fromEnum (AnotherFileChooserAction k :: Int
k) = Int
k

    toEnum :: Int -> FileChooserAction
toEnum 0 = FileChooserAction
FileChooserActionOpen
    toEnum 1 = FileChooserAction
FileChooserActionSave
    toEnum 2 = FileChooserAction
FileChooserActionSelectFolder
    toEnum 3 = FileChooserAction
FileChooserActionCreateFolder
    toEnum k :: Int
k = Int -> FileChooserAction
AnotherFileChooserAction Int
k

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

foreign import ccall "gtk_file_chooser_action_get_type" c_gtk_file_chooser_action_get_type :: 
    IO GType

instance BoxedEnum FileChooserAction where
    boxedEnumType :: FileChooserAction -> IO GType
boxedEnumType _ = IO GType
c_gtk_file_chooser_action_get_type

-- Enum ExpanderStyle
-- | Used to specify the style of the expanders drawn by a t'GI.Gtk.Objects.TreeView.TreeView'.
data ExpanderStyle = 
      ExpanderStyleCollapsed
    -- ^ The style used for a collapsed subtree.
    | ExpanderStyleSemiCollapsed
    -- ^ Intermediate style used during animation.
    | ExpanderStyleSemiExpanded
    -- ^ Intermediate style used during animation.
    | ExpanderStyleExpanded
    -- ^ The style used for an expanded subtree.
    | AnotherExpanderStyle Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ExpanderStyle -> ShowS
[ExpanderStyle] -> ShowS
ExpanderStyle -> String
(Int -> ExpanderStyle -> ShowS)
-> (ExpanderStyle -> String)
-> ([ExpanderStyle] -> ShowS)
-> Show ExpanderStyle
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ExpanderStyle] -> ShowS
$cshowList :: [ExpanderStyle] -> ShowS
show :: ExpanderStyle -> String
$cshow :: ExpanderStyle -> String
showsPrec :: Int -> ExpanderStyle -> ShowS
$cshowsPrec :: Int -> ExpanderStyle -> ShowS
Show, ExpanderStyle -> ExpanderStyle -> Bool
(ExpanderStyle -> ExpanderStyle -> Bool)
-> (ExpanderStyle -> ExpanderStyle -> Bool) -> Eq ExpanderStyle
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ExpanderStyle -> ExpanderStyle -> Bool
$c/= :: ExpanderStyle -> ExpanderStyle -> Bool
== :: ExpanderStyle -> ExpanderStyle -> Bool
$c== :: ExpanderStyle -> ExpanderStyle -> Bool
Eq)

instance P.Enum ExpanderStyle where
    fromEnum :: ExpanderStyle -> Int
fromEnum ExpanderStyleCollapsed = 0
    fromEnum ExpanderStyleSemiCollapsed = 1
    fromEnum ExpanderStyleSemiExpanded = 2
    fromEnum ExpanderStyleExpanded = 3
    fromEnum (AnotherExpanderStyle k :: Int
k) = Int
k

    toEnum :: Int -> ExpanderStyle
toEnum 0 = ExpanderStyle
ExpanderStyleCollapsed
    toEnum 1 = ExpanderStyle
ExpanderStyleSemiCollapsed
    toEnum 2 = ExpanderStyle
ExpanderStyleSemiExpanded
    toEnum 3 = ExpanderStyle
ExpanderStyleExpanded
    toEnum k :: Int
k = Int -> ExpanderStyle
AnotherExpanderStyle Int
k

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

foreign import ccall "gtk_expander_style_get_type" c_gtk_expander_style_get_type :: 
    IO GType

instance BoxedEnum ExpanderStyle where
    boxedEnumType :: ExpanderStyle -> IO GType
boxedEnumType _ = IO GType
c_gtk_expander_style_get_type

-- Enum EventSequenceState
-- | Describes the state of a t'GI.Gdk.Structs.EventSequence.EventSequence' in a t'GI.Gtk.Objects.Gesture.Gesture'.
-- 
-- /Since: 3.14/
data EventSequenceState = 
      EventSequenceStateNone
    -- ^ The sequence is handled, but not grabbed.
    | EventSequenceStateClaimed
    -- ^ The sequence is handled and grabbed.
    | EventSequenceStateDenied
    -- ^ The sequence is denied.
    | AnotherEventSequenceState Int
    -- ^ Catch-all for unknown values
    deriving (Int -> EventSequenceState -> ShowS
[EventSequenceState] -> ShowS
EventSequenceState -> String
(Int -> EventSequenceState -> ShowS)
-> (EventSequenceState -> String)
-> ([EventSequenceState] -> ShowS)
-> Show EventSequenceState
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [EventSequenceState] -> ShowS
$cshowList :: [EventSequenceState] -> ShowS
show :: EventSequenceState -> String
$cshow :: EventSequenceState -> String
showsPrec :: Int -> EventSequenceState -> ShowS
$cshowsPrec :: Int -> EventSequenceState -> ShowS
Show, EventSequenceState -> EventSequenceState -> Bool
(EventSequenceState -> EventSequenceState -> Bool)
-> (EventSequenceState -> EventSequenceState -> Bool)
-> Eq EventSequenceState
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: EventSequenceState -> EventSequenceState -> Bool
$c/= :: EventSequenceState -> EventSequenceState -> Bool
== :: EventSequenceState -> EventSequenceState -> Bool
$c== :: EventSequenceState -> EventSequenceState -> Bool
Eq)

instance P.Enum EventSequenceState where
    fromEnum :: EventSequenceState -> Int
fromEnum EventSequenceStateNone = 0
    fromEnum EventSequenceStateClaimed = 1
    fromEnum EventSequenceStateDenied = 2
    fromEnum (AnotherEventSequenceState k :: Int
k) = Int
k

    toEnum :: Int -> EventSequenceState
toEnum 0 = EventSequenceState
EventSequenceStateNone
    toEnum 1 = EventSequenceState
EventSequenceStateClaimed
    toEnum 2 = EventSequenceState
EventSequenceStateDenied
    toEnum k :: Int
k = Int -> EventSequenceState
AnotherEventSequenceState Int
k

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

foreign import ccall "gtk_event_sequence_state_get_type" c_gtk_event_sequence_state_get_type :: 
    IO GType

instance BoxedEnum EventSequenceState where
    boxedEnumType :: EventSequenceState -> IO GType
boxedEnumType _ = IO GType
c_gtk_event_sequence_state_get_type

-- Enum EntryIconPosition
-- | Specifies the side of the entry at which an icon is placed.
-- 
-- /Since: 2.16/
data EntryIconPosition = 
      EntryIconPositionPrimary
    -- ^ At the beginning of the entry (depending on the text direction).
    | EntryIconPositionSecondary
    -- ^ At the end of the entry (depending on the text direction).
    | AnotherEntryIconPosition Int
    -- ^ Catch-all for unknown values
    deriving (Int -> EntryIconPosition -> ShowS
[EntryIconPosition] -> ShowS
EntryIconPosition -> String
(Int -> EntryIconPosition -> ShowS)
-> (EntryIconPosition -> String)
-> ([EntryIconPosition] -> ShowS)
-> Show EntryIconPosition
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [EntryIconPosition] -> ShowS
$cshowList :: [EntryIconPosition] -> ShowS
show :: EntryIconPosition -> String
$cshow :: EntryIconPosition -> String
showsPrec :: Int -> EntryIconPosition -> ShowS
$cshowsPrec :: Int -> EntryIconPosition -> ShowS
Show, EntryIconPosition -> EntryIconPosition -> Bool
(EntryIconPosition -> EntryIconPosition -> Bool)
-> (EntryIconPosition -> EntryIconPosition -> Bool)
-> Eq EntryIconPosition
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: EntryIconPosition -> EntryIconPosition -> Bool
$c/= :: EntryIconPosition -> EntryIconPosition -> Bool
== :: EntryIconPosition -> EntryIconPosition -> Bool
$c== :: EntryIconPosition -> EntryIconPosition -> Bool
Eq)

instance P.Enum EntryIconPosition where
    fromEnum :: EntryIconPosition -> Int
fromEnum EntryIconPositionPrimary = 0
    fromEnum EntryIconPositionSecondary = 1
    fromEnum (AnotherEntryIconPosition k :: Int
k) = Int
k

    toEnum :: Int -> EntryIconPosition
toEnum 0 = EntryIconPosition
EntryIconPositionPrimary
    toEnum 1 = EntryIconPosition
EntryIconPositionSecondary
    toEnum k :: Int
k = Int -> EntryIconPosition
AnotherEntryIconPosition Int
k

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

foreign import ccall "gtk_entry_icon_position_get_type" c_gtk_entry_icon_position_get_type :: 
    IO GType

instance BoxedEnum EntryIconPosition where
    boxedEnumType :: EntryIconPosition -> IO GType
boxedEnumType _ = IO GType
c_gtk_entry_icon_position_get_type

-- Enum DragResult
-- | Gives an indication why a drag operation failed.
-- The value can by obtained by connecting to the
-- [dragFailed]("GI.Gtk.Objects.Widget#signal:dragFailed") signal.
data DragResult = 
      DragResultSuccess
    -- ^ The drag operation was successful.
    | DragResultNoTarget
    -- ^ No suitable drag target.
    | DragResultUserCancelled
    -- ^ The user cancelled the drag operation.
    | DragResultTimeoutExpired
    -- ^ The drag operation timed out.
    | DragResultGrabBroken
    -- ^ The pointer or keyboard grab used
    --  for the drag operation was broken.
    | DragResultError
    -- ^ The drag operation failed due to some
    --  unspecified error.
    | AnotherDragResult Int
    -- ^ Catch-all for unknown values
    deriving (Int -> DragResult -> ShowS
[DragResult] -> ShowS
DragResult -> String
(Int -> DragResult -> ShowS)
-> (DragResult -> String)
-> ([DragResult] -> ShowS)
-> Show DragResult
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DragResult] -> ShowS
$cshowList :: [DragResult] -> ShowS
show :: DragResult -> String
$cshow :: DragResult -> String
showsPrec :: Int -> DragResult -> ShowS
$cshowsPrec :: Int -> DragResult -> ShowS
Show, DragResult -> DragResult -> Bool
(DragResult -> DragResult -> Bool)
-> (DragResult -> DragResult -> Bool) -> Eq DragResult
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DragResult -> DragResult -> Bool
$c/= :: DragResult -> DragResult -> Bool
== :: DragResult -> DragResult -> Bool
$c== :: DragResult -> DragResult -> Bool
Eq)

instance P.Enum DragResult where
    fromEnum :: DragResult -> Int
fromEnum DragResultSuccess = 0
    fromEnum DragResultNoTarget = 1
    fromEnum DragResultUserCancelled = 2
    fromEnum DragResultTimeoutExpired = 3
    fromEnum DragResultGrabBroken = 4
    fromEnum DragResultError = 5
    fromEnum (AnotherDragResult k :: Int
k) = Int
k

    toEnum :: Int -> DragResult
toEnum 0 = DragResult
DragResultSuccess
    toEnum 1 = DragResult
DragResultNoTarget
    toEnum 2 = DragResult
DragResultUserCancelled
    toEnum 3 = DragResult
DragResultTimeoutExpired
    toEnum 4 = DragResult
DragResultGrabBroken
    toEnum 5 = DragResult
DragResultError
    toEnum k :: Int
k = Int -> DragResult
AnotherDragResult Int
k

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

foreign import ccall "gtk_drag_result_get_type" c_gtk_drag_result_get_type :: 
    IO GType

instance BoxedEnum DragResult where
    boxedEnumType :: DragResult -> IO GType
boxedEnumType _ = IO GType
c_gtk_drag_result_get_type

-- Enum DirectionType
-- | Focus movement types.
data DirectionType = 
      DirectionTypeTabForward
    -- ^ Move forward.
    | DirectionTypeTabBackward
    -- ^ Move backward.
    | DirectionTypeUp
    -- ^ Move up.
    | DirectionTypeDown
    -- ^ Move down.
    | DirectionTypeLeft
    -- ^ Move left.
    | DirectionTypeRight
    -- ^ Move right.
    | AnotherDirectionType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> DirectionType -> ShowS
[DirectionType] -> ShowS
DirectionType -> String
(Int -> DirectionType -> ShowS)
-> (DirectionType -> String)
-> ([DirectionType] -> ShowS)
-> Show DirectionType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DirectionType] -> ShowS
$cshowList :: [DirectionType] -> ShowS
show :: DirectionType -> String
$cshow :: DirectionType -> String
showsPrec :: Int -> DirectionType -> ShowS
$cshowsPrec :: Int -> DirectionType -> ShowS
Show, DirectionType -> DirectionType -> Bool
(DirectionType -> DirectionType -> Bool)
-> (DirectionType -> DirectionType -> Bool) -> Eq DirectionType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DirectionType -> DirectionType -> Bool
$c/= :: DirectionType -> DirectionType -> Bool
== :: DirectionType -> DirectionType -> Bool
$c== :: DirectionType -> DirectionType -> Bool
Eq)

instance P.Enum DirectionType where
    fromEnum :: DirectionType -> Int
fromEnum DirectionTypeTabForward = 0
    fromEnum DirectionTypeTabBackward = 1
    fromEnum DirectionTypeUp = 2
    fromEnum DirectionTypeDown = 3
    fromEnum DirectionTypeLeft = 4
    fromEnum DirectionTypeRight = 5
    fromEnum (AnotherDirectionType k :: Int
k) = Int
k

    toEnum :: Int -> DirectionType
toEnum 0 = DirectionType
DirectionTypeTabForward
    toEnum 1 = DirectionType
DirectionTypeTabBackward
    toEnum 2 = DirectionType
DirectionTypeUp
    toEnum 3 = DirectionType
DirectionTypeDown
    toEnum 4 = DirectionType
DirectionTypeLeft
    toEnum 5 = DirectionType
DirectionTypeRight
    toEnum k :: Int
k = Int -> DirectionType
AnotherDirectionType Int
k

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

foreign import ccall "gtk_direction_type_get_type" c_gtk_direction_type_get_type :: 
    IO GType

instance BoxedEnum DirectionType where
    boxedEnumType :: DirectionType -> IO GType
boxedEnumType _ = IO GType
c_gtk_direction_type_get_type

-- Enum DeleteType
-- | See also: [deleteFromCursor]("GI.Gtk.Objects.Entry#signal:deleteFromCursor").
data DeleteType = 
      DeleteTypeChars
    -- ^ Delete characters.
    | DeleteTypeWordEnds
    -- ^ Delete only the portion of the word to the
    --   left\/right of cursor if we’re in the middle of a word.
    | DeleteTypeWords
    -- ^ Delete words.
    | DeleteTypeDisplayLines
    -- ^ Delete display-lines. Display-lines
    --   refers to the visible lines, with respect to to the current line
    --   breaks. As opposed to paragraphs, which are defined by line
    --   breaks in the input.
    | DeleteTypeDisplayLineEnds
    -- ^ Delete only the portion of the
    --   display-line to the left\/right of cursor.
    | DeleteTypeParagraphEnds
    -- ^ Delete to the end of the
    --   paragraph. Like C-k in Emacs (or its reverse).
    | DeleteTypeParagraphs
    -- ^ Delete entire line. Like C-k in pico.
    | DeleteTypeWhitespace
    -- ^ Delete only whitespace. Like M-\\ in Emacs.
    | AnotherDeleteType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> DeleteType -> ShowS
[DeleteType] -> ShowS
DeleteType -> String
(Int -> DeleteType -> ShowS)
-> (DeleteType -> String)
-> ([DeleteType] -> ShowS)
-> Show DeleteType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DeleteType] -> ShowS
$cshowList :: [DeleteType] -> ShowS
show :: DeleteType -> String
$cshow :: DeleteType -> String
showsPrec :: Int -> DeleteType -> ShowS
$cshowsPrec :: Int -> DeleteType -> ShowS
Show, DeleteType -> DeleteType -> Bool
(DeleteType -> DeleteType -> Bool)
-> (DeleteType -> DeleteType -> Bool) -> Eq DeleteType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DeleteType -> DeleteType -> Bool
$c/= :: DeleteType -> DeleteType -> Bool
== :: DeleteType -> DeleteType -> Bool
$c== :: DeleteType -> DeleteType -> Bool
Eq)

instance P.Enum DeleteType where
    fromEnum :: DeleteType -> Int
fromEnum DeleteTypeChars = 0
    fromEnum DeleteTypeWordEnds = 1
    fromEnum DeleteTypeWords = 2
    fromEnum DeleteTypeDisplayLines = 3
    fromEnum DeleteTypeDisplayLineEnds = 4
    fromEnum DeleteTypeParagraphEnds = 5
    fromEnum DeleteTypeParagraphs = 6
    fromEnum DeleteTypeWhitespace = 7
    fromEnum (AnotherDeleteType k :: Int
k) = Int
k

    toEnum :: Int -> DeleteType
toEnum 0 = DeleteType
DeleteTypeChars
    toEnum 1 = DeleteType
DeleteTypeWordEnds
    toEnum 2 = DeleteType
DeleteTypeWords
    toEnum 3 = DeleteType
DeleteTypeDisplayLines
    toEnum 4 = DeleteType
DeleteTypeDisplayLineEnds
    toEnum 5 = DeleteType
DeleteTypeParagraphEnds
    toEnum 6 = DeleteType
DeleteTypeParagraphs
    toEnum 7 = DeleteType
DeleteTypeWhitespace
    toEnum k :: Int
k = Int -> DeleteType
AnotherDeleteType Int
k

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

foreign import ccall "gtk_delete_type_get_type" c_gtk_delete_type_get_type :: 
    IO GType

instance BoxedEnum DeleteType where
    boxedEnumType :: DeleteType -> IO GType
boxedEnumType _ = IO GType
c_gtk_delete_type_get_type

-- Enum CssSectionType
-- | The different types of sections indicate parts of a CSS document as
-- parsed by GTK’s CSS parser. They are oriented towards the
-- <http://www.w3.org/TR/CSS21/grammar.html CSS Grammar>,
-- but may contain extensions.
-- 
-- More types might be added in the future as the parser incorporates
-- more features.
-- 
-- /Since: 3.2/
data CssSectionType = 
      CssSectionTypeDocument
    -- ^ The section describes a complete document.
    --   This section time is the only one where 'GI.Gtk.Structs.CssSection.cssSectionGetParent'
    --   might return 'P.Nothing'.
    | CssSectionTypeImport
    -- ^ The section defines an import rule.
    | CssSectionTypeColorDefinition
    -- ^ The section defines a color. This
    --   is a GTK extension to CSS.
    | CssSectionTypeBindingSet
    -- ^ The section defines a binding set. This
    --   is a GTK extension to CSS.
    | CssSectionTypeRuleset
    -- ^ The section defines a CSS ruleset.
    | CssSectionTypeSelector
    -- ^ The section defines a CSS selector.
    | CssSectionTypeDeclaration
    -- ^ The section defines the declaration of
    --   a CSS variable.
    | CssSectionTypeValue
    -- ^ The section defines the value of a CSS declaration.
    | CssSectionTypeKeyframes
    -- ^ The section defines keyframes. See <http://dev.w3.org/csswg/css3-animations/#keyframes CSS
    --   Animations> for details. Since 3.6
    | AnotherCssSectionType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> CssSectionType -> ShowS
[CssSectionType] -> ShowS
CssSectionType -> String
(Int -> CssSectionType -> ShowS)
-> (CssSectionType -> String)
-> ([CssSectionType] -> ShowS)
-> Show CssSectionType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CssSectionType] -> ShowS
$cshowList :: [CssSectionType] -> ShowS
show :: CssSectionType -> String
$cshow :: CssSectionType -> String
showsPrec :: Int -> CssSectionType -> ShowS
$cshowsPrec :: Int -> CssSectionType -> ShowS
Show, CssSectionType -> CssSectionType -> Bool
(CssSectionType -> CssSectionType -> Bool)
-> (CssSectionType -> CssSectionType -> Bool) -> Eq CssSectionType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CssSectionType -> CssSectionType -> Bool
$c/= :: CssSectionType -> CssSectionType -> Bool
== :: CssSectionType -> CssSectionType -> Bool
$c== :: CssSectionType -> CssSectionType -> Bool
Eq)

instance P.Enum CssSectionType where
    fromEnum :: CssSectionType -> Int
fromEnum CssSectionTypeDocument = 0
    fromEnum CssSectionTypeImport = 1
    fromEnum CssSectionTypeColorDefinition = 2
    fromEnum CssSectionTypeBindingSet = 3
    fromEnum CssSectionTypeRuleset = 4
    fromEnum CssSectionTypeSelector = 5
    fromEnum CssSectionTypeDeclaration = 6
    fromEnum CssSectionTypeValue = 7
    fromEnum CssSectionTypeKeyframes = 8
    fromEnum (AnotherCssSectionType k :: Int
k) = Int
k

    toEnum :: Int -> CssSectionType
toEnum 0 = CssSectionType
CssSectionTypeDocument
    toEnum 1 = CssSectionType
CssSectionTypeImport
    toEnum 2 = CssSectionType
CssSectionTypeColorDefinition
    toEnum 3 = CssSectionType
CssSectionTypeBindingSet
    toEnum 4 = CssSectionType
CssSectionTypeRuleset
    toEnum 5 = CssSectionType
CssSectionTypeSelector
    toEnum 6 = CssSectionType
CssSectionTypeDeclaration
    toEnum 7 = CssSectionType
CssSectionTypeValue
    toEnum 8 = CssSectionType
CssSectionTypeKeyframes
    toEnum k :: Int
k = Int -> CssSectionType
AnotherCssSectionType Int
k

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

foreign import ccall "gtk_css_section_type_get_type" c_gtk_css_section_type_get_type :: 
    IO GType

instance BoxedEnum CssSectionType where
    boxedEnumType :: CssSectionType -> IO GType
boxedEnumType _ = IO GType
c_gtk_css_section_type_get_type

-- Enum CssProviderError
-- | Error codes for @/GTK_CSS_PROVIDER_ERROR/@.
data CssProviderError = 
      CssProviderErrorFailed
    -- ^ Failed.
    | CssProviderErrorSyntax
    -- ^ Syntax error.
    | CssProviderErrorImport
    -- ^ Import error.
    | CssProviderErrorName
    -- ^ Name error.
    | CssProviderErrorDeprecated
    -- ^ Deprecation error.
    | CssProviderErrorUnknownValue
    -- ^ Unknown value.
    | AnotherCssProviderError Int
    -- ^ Catch-all for unknown values
    deriving (Int -> CssProviderError -> ShowS
[CssProviderError] -> ShowS
CssProviderError -> String
(Int -> CssProviderError -> ShowS)
-> (CssProviderError -> String)
-> ([CssProviderError] -> ShowS)
-> Show CssProviderError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CssProviderError] -> ShowS
$cshowList :: [CssProviderError] -> ShowS
show :: CssProviderError -> String
$cshow :: CssProviderError -> String
showsPrec :: Int -> CssProviderError -> ShowS
$cshowsPrec :: Int -> CssProviderError -> ShowS
Show, CssProviderError -> CssProviderError -> Bool
(CssProviderError -> CssProviderError -> Bool)
-> (CssProviderError -> CssProviderError -> Bool)
-> Eq CssProviderError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CssProviderError -> CssProviderError -> Bool
$c/= :: CssProviderError -> CssProviderError -> Bool
== :: CssProviderError -> CssProviderError -> Bool
$c== :: CssProviderError -> CssProviderError -> Bool
Eq)

instance P.Enum CssProviderError where
    fromEnum :: CssProviderError -> Int
fromEnum CssProviderErrorFailed = 0
    fromEnum CssProviderErrorSyntax = 1
    fromEnum CssProviderErrorImport = 2
    fromEnum CssProviderErrorName = 3
    fromEnum CssProviderErrorDeprecated = 4
    fromEnum CssProviderErrorUnknownValue = 5
    fromEnum (AnotherCssProviderError k :: Int
k) = Int
k

    toEnum :: Int -> CssProviderError
toEnum 0 = CssProviderError
CssProviderErrorFailed
    toEnum 1 = CssProviderError
CssProviderErrorSyntax
    toEnum 2 = CssProviderError
CssProviderErrorImport
    toEnum 3 = CssProviderError
CssProviderErrorName
    toEnum 4 = CssProviderError
CssProviderErrorDeprecated
    toEnum 5 = CssProviderError
CssProviderErrorUnknownValue
    toEnum k :: Int
k = Int -> CssProviderError
AnotherCssProviderError Int
k

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

instance GErrorClass CssProviderError where
    gerrorClassDomain :: CssProviderError -> Text
gerrorClassDomain _ = "gtk-css-provider-error-quark"

-- | Catch exceptions of type `CssProviderError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
catchCssProviderError ::
    IO a ->
    (CssProviderError -> GErrorMessage -> IO a) ->
    IO a
catchCssProviderError :: IO a -> (CssProviderError -> Text -> IO a) -> IO a
catchCssProviderError = IO a -> (CssProviderError -> Text -> IO a) -> IO a
forall err a.
GErrorClass err =>
IO a -> (err -> Text -> IO a) -> IO a
catchGErrorJustDomain

-- | Handle exceptions of type `CssProviderError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
handleCssProviderError ::
    (CssProviderError -> GErrorMessage -> IO a) ->
    IO a ->
    IO a
handleCssProviderError :: (CssProviderError -> Text -> IO a) -> IO a -> IO a
handleCssProviderError = (CssProviderError -> Text -> IO a) -> IO a -> IO a
forall err a.
GErrorClass err =>
(err -> Text -> IO a) -> IO a -> IO a
handleGErrorJustDomain

foreign import ccall "gtk_css_provider_error_get_type" c_gtk_css_provider_error_get_type :: 
    IO GType

instance BoxedEnum CssProviderError where
    boxedEnumType :: CssProviderError -> IO GType
boxedEnumType _ = IO GType
c_gtk_css_provider_error_get_type

-- Enum CornerType
-- | Specifies which corner a child widget should be placed in when packed into
-- a t'GI.Gtk.Objects.ScrolledWindow.ScrolledWindow'. This is effectively the opposite of where the scroll
-- bars are placed.
data CornerType = 
      CornerTypeTopLeft
    -- ^ Place the scrollbars on the right and bottom of the
    --  widget (default behaviour).
    | CornerTypeBottomLeft
    -- ^ Place the scrollbars on the top and right of the
    --  widget.
    | CornerTypeTopRight
    -- ^ Place the scrollbars on the left and bottom of the
    --  widget.
    | CornerTypeBottomRight
    -- ^ Place the scrollbars on the top and left of the
    --  widget.
    | AnotherCornerType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> CornerType -> ShowS
[CornerType] -> ShowS
CornerType -> String
(Int -> CornerType -> ShowS)
-> (CornerType -> String)
-> ([CornerType] -> ShowS)
-> Show CornerType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CornerType] -> ShowS
$cshowList :: [CornerType] -> ShowS
show :: CornerType -> String
$cshow :: CornerType -> String
showsPrec :: Int -> CornerType -> ShowS
$cshowsPrec :: Int -> CornerType -> ShowS
Show, CornerType -> CornerType -> Bool
(CornerType -> CornerType -> Bool)
-> (CornerType -> CornerType -> Bool) -> Eq CornerType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CornerType -> CornerType -> Bool
$c/= :: CornerType -> CornerType -> Bool
== :: CornerType -> CornerType -> Bool
$c== :: CornerType -> CornerType -> Bool
Eq)

instance P.Enum CornerType where
    fromEnum :: CornerType -> Int
fromEnum CornerTypeTopLeft = 0
    fromEnum CornerTypeBottomLeft = 1
    fromEnum CornerTypeTopRight = 2
    fromEnum CornerTypeBottomRight = 3
    fromEnum (AnotherCornerType k :: Int
k) = Int
k

    toEnum :: Int -> CornerType
toEnum 0 = CornerType
CornerTypeTopLeft
    toEnum 1 = CornerType
CornerTypeBottomLeft
    toEnum 2 = CornerType
CornerTypeTopRight
    toEnum 3 = CornerType
CornerTypeBottomRight
    toEnum k :: Int
k = Int -> CornerType
AnotherCornerType Int
k

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

foreign import ccall "gtk_corner_type_get_type" c_gtk_corner_type_get_type :: 
    IO GType

instance BoxedEnum CornerType where
    boxedEnumType :: CornerType -> IO GType
boxedEnumType _ = IO GType
c_gtk_corner_type_get_type

-- Enum CellRendererMode
-- | Identifies how the user can interact with a particular cell.
data CellRendererMode = 
      CellRendererModeInert
    -- ^ The cell is just for display
    --  and cannot be interacted with.  Note that this doesn’t mean that eg. the
    --  row being drawn can’t be selected -- just that a particular element of
    --  it cannot be individually modified.
    | CellRendererModeActivatable
    -- ^ The cell can be clicked.
    | CellRendererModeEditable
    -- ^ The cell can be edited or otherwise modified.
    | AnotherCellRendererMode Int
    -- ^ Catch-all for unknown values
    deriving (Int -> CellRendererMode -> ShowS
[CellRendererMode] -> ShowS
CellRendererMode -> String
(Int -> CellRendererMode -> ShowS)
-> (CellRendererMode -> String)
-> ([CellRendererMode] -> ShowS)
-> Show CellRendererMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CellRendererMode] -> ShowS
$cshowList :: [CellRendererMode] -> ShowS
show :: CellRendererMode -> String
$cshow :: CellRendererMode -> String
showsPrec :: Int -> CellRendererMode -> ShowS
$cshowsPrec :: Int -> CellRendererMode -> ShowS
Show, CellRendererMode -> CellRendererMode -> Bool
(CellRendererMode -> CellRendererMode -> Bool)
-> (CellRendererMode -> CellRendererMode -> Bool)
-> Eq CellRendererMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CellRendererMode -> CellRendererMode -> Bool
$c/= :: CellRendererMode -> CellRendererMode -> Bool
== :: CellRendererMode -> CellRendererMode -> Bool
$c== :: CellRendererMode -> CellRendererMode -> Bool
Eq)

instance P.Enum CellRendererMode where
    fromEnum :: CellRendererMode -> Int
fromEnum CellRendererModeInert = 0
    fromEnum CellRendererModeActivatable = 1
    fromEnum CellRendererModeEditable = 2
    fromEnum (AnotherCellRendererMode k :: Int
k) = Int
k

    toEnum :: Int -> CellRendererMode
toEnum 0 = CellRendererMode
CellRendererModeInert
    toEnum 1 = CellRendererMode
CellRendererModeActivatable
    toEnum 2 = CellRendererMode
CellRendererModeEditable
    toEnum k :: Int
k = Int -> CellRendererMode
AnotherCellRendererMode Int
k

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

foreign import ccall "gtk_cell_renderer_mode_get_type" c_gtk_cell_renderer_mode_get_type :: 
    IO GType

instance BoxedEnum CellRendererMode where
    boxedEnumType :: CellRendererMode -> IO GType
boxedEnumType _ = IO GType
c_gtk_cell_renderer_mode_get_type

-- Enum CellRendererAccelMode
-- | Determines if the edited accelerators are GTK+ accelerators. If
-- they are, consumed modifiers are suppressed, only accelerators
-- accepted by GTK+ are allowed, and the accelerators are rendered
-- in the same way as they are in menus.
data CellRendererAccelMode = 
      CellRendererAccelModeGtk
    -- ^ GTK+ accelerators mode
    | CellRendererAccelModeOther
    -- ^ Other accelerator mode
    | AnotherCellRendererAccelMode Int
    -- ^ Catch-all for unknown values
    deriving (Int -> CellRendererAccelMode -> ShowS
[CellRendererAccelMode] -> ShowS
CellRendererAccelMode -> String
(Int -> CellRendererAccelMode -> ShowS)
-> (CellRendererAccelMode -> String)
-> ([CellRendererAccelMode] -> ShowS)
-> Show CellRendererAccelMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CellRendererAccelMode] -> ShowS
$cshowList :: [CellRendererAccelMode] -> ShowS
show :: CellRendererAccelMode -> String
$cshow :: CellRendererAccelMode -> String
showsPrec :: Int -> CellRendererAccelMode -> ShowS
$cshowsPrec :: Int -> CellRendererAccelMode -> ShowS
Show, CellRendererAccelMode -> CellRendererAccelMode -> Bool
(CellRendererAccelMode -> CellRendererAccelMode -> Bool)
-> (CellRendererAccelMode -> CellRendererAccelMode -> Bool)
-> Eq CellRendererAccelMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CellRendererAccelMode -> CellRendererAccelMode -> Bool
$c/= :: CellRendererAccelMode -> CellRendererAccelMode -> Bool
== :: CellRendererAccelMode -> CellRendererAccelMode -> Bool
$c== :: CellRendererAccelMode -> CellRendererAccelMode -> Bool
Eq)

instance P.Enum CellRendererAccelMode where
    fromEnum :: CellRendererAccelMode -> Int
fromEnum CellRendererAccelModeGtk = 0
    fromEnum CellRendererAccelModeOther = 1
    fromEnum (AnotherCellRendererAccelMode k :: Int
k) = Int
k

    toEnum :: Int -> CellRendererAccelMode
toEnum 0 = CellRendererAccelMode
CellRendererAccelModeGtk
    toEnum 1 = CellRendererAccelMode
CellRendererAccelModeOther
    toEnum k :: Int
k = Int -> CellRendererAccelMode
AnotherCellRendererAccelMode Int
k

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

foreign import ccall "gtk_cell_renderer_accel_mode_get_type" c_gtk_cell_renderer_accel_mode_get_type :: 
    IO GType

instance BoxedEnum CellRendererAccelMode where
    boxedEnumType :: CellRendererAccelMode -> IO GType
boxedEnumType _ = IO GType
c_gtk_cell_renderer_accel_mode_get_type

-- Enum ButtonsType
-- | Prebuilt sets of buttons for the dialog. If
-- none of these choices are appropriate, simply use 'GI.Gtk.Enums.ButtonsTypeNone'
-- then call @/gtk_dialog_add_buttons()/@.
-- 
-- > Please note that 'GI.Gtk.Enums.ButtonsTypeOk', 'GI.Gtk.Enums.ButtonsTypeYesNo'
-- > and 'GI.Gtk.Enums.ButtonsTypeOkCancel' are discouraged by the
-- > <http://library.gnome.org/devel/hig-book/stable/ GNOME Human Interface Guidelines>.
data ButtonsType = 
      ButtonsTypeNone
    -- ^ no buttons at all
    | ButtonsTypeOk
    -- ^ an OK button
    | ButtonsTypeClose
    -- ^ a Close button
    | ButtonsTypeCancel
    -- ^ a Cancel button
    | ButtonsTypeYesNo
    -- ^ Yes and No buttons
    | ButtonsTypeOkCancel
    -- ^ OK and Cancel buttons
    | AnotherButtonsType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ButtonsType -> ShowS
[ButtonsType] -> ShowS
ButtonsType -> String
(Int -> ButtonsType -> ShowS)
-> (ButtonsType -> String)
-> ([ButtonsType] -> ShowS)
-> Show ButtonsType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ButtonsType] -> ShowS
$cshowList :: [ButtonsType] -> ShowS
show :: ButtonsType -> String
$cshow :: ButtonsType -> String
showsPrec :: Int -> ButtonsType -> ShowS
$cshowsPrec :: Int -> ButtonsType -> ShowS
Show, ButtonsType -> ButtonsType -> Bool
(ButtonsType -> ButtonsType -> Bool)
-> (ButtonsType -> ButtonsType -> Bool) -> Eq ButtonsType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ButtonsType -> ButtonsType -> Bool
$c/= :: ButtonsType -> ButtonsType -> Bool
== :: ButtonsType -> ButtonsType -> Bool
$c== :: ButtonsType -> ButtonsType -> Bool
Eq)

instance P.Enum ButtonsType where
    fromEnum :: ButtonsType -> Int
fromEnum ButtonsTypeNone = 0
    fromEnum ButtonsTypeOk = 1
    fromEnum ButtonsTypeClose = 2
    fromEnum ButtonsTypeCancel = 3
    fromEnum ButtonsTypeYesNo = 4
    fromEnum ButtonsTypeOkCancel = 5
    fromEnum (AnotherButtonsType k :: Int
k) = Int
k

    toEnum :: Int -> ButtonsType
toEnum 0 = ButtonsType
ButtonsTypeNone
    toEnum 1 = ButtonsType
ButtonsTypeOk
    toEnum 2 = ButtonsType
ButtonsTypeClose
    toEnum 3 = ButtonsType
ButtonsTypeCancel
    toEnum 4 = ButtonsType
ButtonsTypeYesNo
    toEnum 5 = ButtonsType
ButtonsTypeOkCancel
    toEnum k :: Int
k = Int -> ButtonsType
AnotherButtonsType Int
k

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

foreign import ccall "gtk_buttons_type_get_type" c_gtk_buttons_type_get_type :: 
    IO GType

instance BoxedEnum ButtonsType where
    boxedEnumType :: ButtonsType -> IO GType
boxedEnumType _ = IO GType
c_gtk_buttons_type_get_type

-- Enum ButtonRole
-- | The role specifies the desired appearance of a t'GI.Gtk.Objects.ModelButton.ModelButton'.
data ButtonRole = 
      ButtonRoleNormal
    -- ^ A plain button
    | ButtonRoleCheck
    -- ^ A check button
    | ButtonRoleRadio
    -- ^ A radio button
    | AnotherButtonRole Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ButtonRole -> ShowS
[ButtonRole] -> ShowS
ButtonRole -> String
(Int -> ButtonRole -> ShowS)
-> (ButtonRole -> String)
-> ([ButtonRole] -> ShowS)
-> Show ButtonRole
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ButtonRole] -> ShowS
$cshowList :: [ButtonRole] -> ShowS
show :: ButtonRole -> String
$cshow :: ButtonRole -> String
showsPrec :: Int -> ButtonRole -> ShowS
$cshowsPrec :: Int -> ButtonRole -> ShowS
Show, ButtonRole -> ButtonRole -> Bool
(ButtonRole -> ButtonRole -> Bool)
-> (ButtonRole -> ButtonRole -> Bool) -> Eq ButtonRole
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ButtonRole -> ButtonRole -> Bool
$c/= :: ButtonRole -> ButtonRole -> Bool
== :: ButtonRole -> ButtonRole -> Bool
$c== :: ButtonRole -> ButtonRole -> Bool
Eq)

instance P.Enum ButtonRole where
    fromEnum :: ButtonRole -> Int
fromEnum ButtonRoleNormal = 0
    fromEnum ButtonRoleCheck = 1
    fromEnum ButtonRoleRadio = 2
    fromEnum (AnotherButtonRole k :: Int
k) = Int
k

    toEnum :: Int -> ButtonRole
toEnum 0 = ButtonRole
ButtonRoleNormal
    toEnum 1 = ButtonRole
ButtonRoleCheck
    toEnum 2 = ButtonRole
ButtonRoleRadio
    toEnum k :: Int
k = Int -> ButtonRole
AnotherButtonRole Int
k

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

foreign import ccall "gtk_button_role_get_type" c_gtk_button_role_get_type :: 
    IO GType

instance BoxedEnum ButtonRole where
    boxedEnumType :: ButtonRole -> IO GType
boxedEnumType _ = IO GType
c_gtk_button_role_get_type

-- Enum ButtonBoxStyle
-- | Used to dictate the style that a t'GI.Gtk.Objects.ButtonBox.ButtonBox' uses to layout the buttons it
-- contains.
data ButtonBoxStyle = 
      ButtonBoxStyleSpread
    -- ^ Buttons are evenly spread across the box.
    | ButtonBoxStyleEdge
    -- ^ Buttons are placed at the edges of the box.
    | ButtonBoxStyleStart
    -- ^ Buttons are grouped towards the start of the box,
    --   (on the left for a HBox, or the top for a VBox).
    | ButtonBoxStyleEnd
    -- ^ Buttons are grouped towards the end of the box,
    --   (on the right for a HBox, or the bottom for a VBox).
    | ButtonBoxStyleCenter
    -- ^ Buttons are centered in the box. Since 2.12.
    | ButtonBoxStyleExpand
    -- ^ Buttons expand to fill the box. This entails giving
    --   buttons a \"linked\" appearance, making button sizes homogeneous, and
    --   setting spacing to 0 (same as calling 'GI.Gtk.Objects.Box.boxSetHomogeneous' and
    --   'GI.Gtk.Objects.Box.boxSetSpacing' manually). Since 3.12.
    | AnotherButtonBoxStyle Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ButtonBoxStyle -> ShowS
[ButtonBoxStyle] -> ShowS
ButtonBoxStyle -> String
(Int -> ButtonBoxStyle -> ShowS)
-> (ButtonBoxStyle -> String)
-> ([ButtonBoxStyle] -> ShowS)
-> Show ButtonBoxStyle
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ButtonBoxStyle] -> ShowS
$cshowList :: [ButtonBoxStyle] -> ShowS
show :: ButtonBoxStyle -> String
$cshow :: ButtonBoxStyle -> String
showsPrec :: Int -> ButtonBoxStyle -> ShowS
$cshowsPrec :: Int -> ButtonBoxStyle -> ShowS
Show, ButtonBoxStyle -> ButtonBoxStyle -> Bool
(ButtonBoxStyle -> ButtonBoxStyle -> Bool)
-> (ButtonBoxStyle -> ButtonBoxStyle -> Bool) -> Eq ButtonBoxStyle
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ButtonBoxStyle -> ButtonBoxStyle -> Bool
$c/= :: ButtonBoxStyle -> ButtonBoxStyle -> Bool
== :: ButtonBoxStyle -> ButtonBoxStyle -> Bool
$c== :: ButtonBoxStyle -> ButtonBoxStyle -> Bool
Eq)

instance P.Enum ButtonBoxStyle where
    fromEnum :: ButtonBoxStyle -> Int
fromEnum ButtonBoxStyleSpread = 1
    fromEnum ButtonBoxStyleEdge = 2
    fromEnum ButtonBoxStyleStart = 3
    fromEnum ButtonBoxStyleEnd = 4
    fromEnum ButtonBoxStyleCenter = 5
    fromEnum ButtonBoxStyleExpand = 6
    fromEnum (AnotherButtonBoxStyle k :: Int
k) = Int
k

    toEnum :: Int -> ButtonBoxStyle
toEnum 1 = ButtonBoxStyle
ButtonBoxStyleSpread
    toEnum 2 = ButtonBoxStyle
ButtonBoxStyleEdge
    toEnum 3 = ButtonBoxStyle
ButtonBoxStyleStart
    toEnum 4 = ButtonBoxStyle
ButtonBoxStyleEnd
    toEnum 5 = ButtonBoxStyle
ButtonBoxStyleCenter
    toEnum 6 = ButtonBoxStyle
ButtonBoxStyleExpand
    toEnum k :: Int
k = Int -> ButtonBoxStyle
AnotherButtonBoxStyle Int
k

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

foreign import ccall "gtk_button_box_style_get_type" c_gtk_button_box_style_get_type :: 
    IO GType

instance BoxedEnum ButtonBoxStyle where
    boxedEnumType :: ButtonBoxStyle -> IO GType
boxedEnumType _ = IO GType
c_gtk_button_box_style_get_type

-- Enum BuilderError
-- | Error codes that identify various errors that can occur while using
-- t'GI.Gtk.Objects.Builder.Builder'.
data BuilderError = 
      BuilderErrorInvalidTypeFunction
    -- ^ A type-func attribute didn’t name
    --  a function that returns a t'GType'.
    | BuilderErrorUnhandledTag
    -- ^ The input contained a tag that t'GI.Gtk.Objects.Builder.Builder'
    --  can’t handle.
    | BuilderErrorMissingAttribute
    -- ^ An attribute that is required by
    --  t'GI.Gtk.Objects.Builder.Builder' was missing.
    | BuilderErrorInvalidAttribute
    -- ^ t'GI.Gtk.Objects.Builder.Builder' found an attribute that
    --  it doesn’t understand.
    | BuilderErrorInvalidTag
    -- ^ t'GI.Gtk.Objects.Builder.Builder' found a tag that
    --  it doesn’t understand.
    | BuilderErrorMissingPropertyValue
    -- ^ A required property value was
    --  missing.
    | BuilderErrorInvalidValue
    -- ^ t'GI.Gtk.Objects.Builder.Builder' couldn’t parse
    --  some attribute value.
    | BuilderErrorVersionMismatch
    -- ^ The input file requires a newer version
    --  of GTK+.
    | BuilderErrorDuplicateId
    -- ^ An object id occurred twice.
    | BuilderErrorObjectTypeRefused
    -- ^ A specified object type is of the same type or
    --  derived from the type of the composite class being extended with builder XML.
    | BuilderErrorTemplateMismatch
    -- ^ The wrong type was specified in a composite class’s template XML
    | BuilderErrorInvalidProperty
    -- ^ The specified property is unknown for the object class.
    | BuilderErrorInvalidSignal
    -- ^ The specified signal is unknown for the object class.
    | BuilderErrorInvalidId
    -- ^ An object id is unknown
    | AnotherBuilderError Int
    -- ^ Catch-all for unknown values
    deriving (Int -> BuilderError -> ShowS
[BuilderError] -> ShowS
BuilderError -> String
(Int -> BuilderError -> ShowS)
-> (BuilderError -> String)
-> ([BuilderError] -> ShowS)
-> Show BuilderError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BuilderError] -> ShowS
$cshowList :: [BuilderError] -> ShowS
show :: BuilderError -> String
$cshow :: BuilderError -> String
showsPrec :: Int -> BuilderError -> ShowS
$cshowsPrec :: Int -> BuilderError -> ShowS
Show, BuilderError -> BuilderError -> Bool
(BuilderError -> BuilderError -> Bool)
-> (BuilderError -> BuilderError -> Bool) -> Eq BuilderError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BuilderError -> BuilderError -> Bool
$c/= :: BuilderError -> BuilderError -> Bool
== :: BuilderError -> BuilderError -> Bool
$c== :: BuilderError -> BuilderError -> Bool
Eq)

instance P.Enum BuilderError where
    fromEnum :: BuilderError -> Int
fromEnum BuilderErrorInvalidTypeFunction = 0
    fromEnum BuilderErrorUnhandledTag = 1
    fromEnum BuilderErrorMissingAttribute = 2
    fromEnum BuilderErrorInvalidAttribute = 3
    fromEnum BuilderErrorInvalidTag = 4
    fromEnum BuilderErrorMissingPropertyValue = 5
    fromEnum BuilderErrorInvalidValue = 6
    fromEnum BuilderErrorVersionMismatch = 7
    fromEnum BuilderErrorDuplicateId = 8
    fromEnum BuilderErrorObjectTypeRefused = 9
    fromEnum BuilderErrorTemplateMismatch = 10
    fromEnum BuilderErrorInvalidProperty = 11
    fromEnum BuilderErrorInvalidSignal = 12
    fromEnum BuilderErrorInvalidId = 13
    fromEnum (AnotherBuilderError k :: Int
k) = Int
k

    toEnum :: Int -> BuilderError
toEnum 0 = BuilderError
BuilderErrorInvalidTypeFunction
    toEnum 1 = BuilderError
BuilderErrorUnhandledTag
    toEnum 2 = BuilderError
BuilderErrorMissingAttribute
    toEnum 3 = BuilderError
BuilderErrorInvalidAttribute
    toEnum 4 = BuilderError
BuilderErrorInvalidTag
    toEnum 5 = BuilderError
BuilderErrorMissingPropertyValue
    toEnum 6 = BuilderError
BuilderErrorInvalidValue
    toEnum 7 = BuilderError
BuilderErrorVersionMismatch
    toEnum 8 = BuilderError
BuilderErrorDuplicateId
    toEnum 9 = BuilderError
BuilderErrorObjectTypeRefused
    toEnum 10 = BuilderError
BuilderErrorTemplateMismatch
    toEnum 11 = BuilderError
BuilderErrorInvalidProperty
    toEnum 12 = BuilderError
BuilderErrorInvalidSignal
    toEnum 13 = BuilderError
BuilderErrorInvalidId
    toEnum k :: Int
k = Int -> BuilderError
AnotherBuilderError Int
k

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

instance GErrorClass BuilderError where
    gerrorClassDomain :: BuilderError -> Text
gerrorClassDomain _ = "gtk-builder-error-quark"

-- | Catch exceptions of type `BuilderError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
catchBuilderError ::
    IO a ->
    (BuilderError -> GErrorMessage -> IO a) ->
    IO a
catchBuilderError :: IO a -> (BuilderError -> Text -> IO a) -> IO a
catchBuilderError = IO a -> (BuilderError -> Text -> IO a) -> IO a
forall err a.
GErrorClass err =>
IO a -> (err -> Text -> IO a) -> IO a
catchGErrorJustDomain

-- | Handle exceptions of type `BuilderError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
handleBuilderError ::
    (BuilderError -> GErrorMessage -> IO a) ->
    IO a ->
    IO a
handleBuilderError :: (BuilderError -> Text -> IO a) -> IO a -> IO a
handleBuilderError = (BuilderError -> Text -> IO a) -> IO a -> IO a
forall err a.
GErrorClass err =>
(err -> Text -> IO a) -> IO a -> IO a
handleGErrorJustDomain

foreign import ccall "gtk_builder_error_get_type" c_gtk_builder_error_get_type :: 
    IO GType

instance BoxedEnum BuilderError where
    boxedEnumType :: BuilderError -> IO GType
boxedEnumType _ = IO GType
c_gtk_builder_error_get_type

-- Enum BorderStyle
-- | Describes how the border of a UI element should be rendered.
data BorderStyle = 
      BorderStyleNone
    -- ^ No visible border
    | BorderStyleSolid
    -- ^ A single line segment
    | BorderStyleInset
    -- ^ Looks as if the content is sunken into the canvas
    | BorderStyleOutset
    -- ^ Looks as if the content is coming out of the canvas
    | BorderStyleHidden
    -- ^ Same as /@gTKBORDERSTYLENONE@/
    | BorderStyleDotted
    -- ^ A series of round dots
    | BorderStyleDashed
    -- ^ A series of square-ended dashes
    | BorderStyleDouble
    -- ^ Two parallel lines with some space between them
    | BorderStyleGroove
    -- ^ Looks as if it were carved in the canvas
    | BorderStyleRidge
    -- ^ Looks as if it were coming out of the canvas
    | AnotherBorderStyle Int
    -- ^ Catch-all for unknown values
    deriving (Int -> BorderStyle -> ShowS
[BorderStyle] -> ShowS
BorderStyle -> String
(Int -> BorderStyle -> ShowS)
-> (BorderStyle -> String)
-> ([BorderStyle] -> ShowS)
-> Show BorderStyle
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BorderStyle] -> ShowS
$cshowList :: [BorderStyle] -> ShowS
show :: BorderStyle -> String
$cshow :: BorderStyle -> String
showsPrec :: Int -> BorderStyle -> ShowS
$cshowsPrec :: Int -> BorderStyle -> ShowS
Show, BorderStyle -> BorderStyle -> Bool
(BorderStyle -> BorderStyle -> Bool)
-> (BorderStyle -> BorderStyle -> Bool) -> Eq BorderStyle
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BorderStyle -> BorderStyle -> Bool
$c/= :: BorderStyle -> BorderStyle -> Bool
== :: BorderStyle -> BorderStyle -> Bool
$c== :: BorderStyle -> BorderStyle -> Bool
Eq)

instance P.Enum BorderStyle where
    fromEnum :: BorderStyle -> Int
fromEnum BorderStyleNone = 0
    fromEnum BorderStyleSolid = 1
    fromEnum BorderStyleInset = 2
    fromEnum BorderStyleOutset = 3
    fromEnum BorderStyleHidden = 4
    fromEnum BorderStyleDotted = 5
    fromEnum BorderStyleDashed = 6
    fromEnum BorderStyleDouble = 7
    fromEnum BorderStyleGroove = 8
    fromEnum BorderStyleRidge = 9
    fromEnum (AnotherBorderStyle k :: Int
k) = Int
k

    toEnum :: Int -> BorderStyle
toEnum 0 = BorderStyle
BorderStyleNone
    toEnum 1 = BorderStyle
BorderStyleSolid
    toEnum 2 = BorderStyle
BorderStyleInset
    toEnum 3 = BorderStyle
BorderStyleOutset
    toEnum 4 = BorderStyle
BorderStyleHidden
    toEnum 5 = BorderStyle
BorderStyleDotted
    toEnum 6 = BorderStyle
BorderStyleDashed
    toEnum 7 = BorderStyle
BorderStyleDouble
    toEnum 8 = BorderStyle
BorderStyleGroove
    toEnum 9 = BorderStyle
BorderStyleRidge
    toEnum k :: Int
k = Int -> BorderStyle
AnotherBorderStyle Int
k

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

foreign import ccall "gtk_border_style_get_type" c_gtk_border_style_get_type :: 
    IO GType

instance BoxedEnum BorderStyle where
    boxedEnumType :: BorderStyle -> IO GType
boxedEnumType _ = IO GType
c_gtk_border_style_get_type

-- Enum BaselinePosition
-- | Whenever a container has some form of natural row it may align
-- children in that row along a common typographical baseline. If
-- the amount of verical space in the row is taller than the total
-- requested height of the baseline-aligned children then it can use a
-- t'GI.Gtk.Enums.BaselinePosition' to select where to put the baseline inside the
-- extra availible space.
-- 
-- /Since: 3.10/
data BaselinePosition = 
      BaselinePositionTop
    -- ^ Align the baseline at the top
    | BaselinePositionCenter
    -- ^ Center the baseline
    | BaselinePositionBottom
    -- ^ Align the baseline at the bottom
    | AnotherBaselinePosition Int
    -- ^ Catch-all for unknown values
    deriving (Int -> BaselinePosition -> ShowS
[BaselinePosition] -> ShowS
BaselinePosition -> String
(Int -> BaselinePosition -> ShowS)
-> (BaselinePosition -> String)
-> ([BaselinePosition] -> ShowS)
-> Show BaselinePosition
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BaselinePosition] -> ShowS
$cshowList :: [BaselinePosition] -> ShowS
show :: BaselinePosition -> String
$cshow :: BaselinePosition -> String
showsPrec :: Int -> BaselinePosition -> ShowS
$cshowsPrec :: Int -> BaselinePosition -> ShowS
Show, BaselinePosition -> BaselinePosition -> Bool
(BaselinePosition -> BaselinePosition -> Bool)
-> (BaselinePosition -> BaselinePosition -> Bool)
-> Eq BaselinePosition
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BaselinePosition -> BaselinePosition -> Bool
$c/= :: BaselinePosition -> BaselinePosition -> Bool
== :: BaselinePosition -> BaselinePosition -> Bool
$c== :: BaselinePosition -> BaselinePosition -> Bool
Eq)

instance P.Enum BaselinePosition where
    fromEnum :: BaselinePosition -> Int
fromEnum BaselinePositionTop = 0
    fromEnum BaselinePositionCenter = 1
    fromEnum BaselinePositionBottom = 2
    fromEnum (AnotherBaselinePosition k :: Int
k) = Int
k

    toEnum :: Int -> BaselinePosition
toEnum 0 = BaselinePosition
BaselinePositionTop
    toEnum 1 = BaselinePosition
BaselinePositionCenter
    toEnum 2 = BaselinePosition
BaselinePositionBottom
    toEnum k :: Int
k = Int -> BaselinePosition
AnotherBaselinePosition Int
k

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

foreign import ccall "gtk_baseline_position_get_type" c_gtk_baseline_position_get_type :: 
    IO GType

instance BoxedEnum BaselinePosition where
    boxedEnumType :: BaselinePosition -> IO GType
boxedEnumType _ = IO GType
c_gtk_baseline_position_get_type

-- Enum AssistantPageType
-- | An enum for determining the page role inside the t'GI.Gtk.Objects.Assistant.Assistant'. It\'s
-- used to handle buttons sensitivity and visibility.
-- 
-- Note that an assistant needs to end its page flow with a page of type
-- 'GI.Gtk.Enums.AssistantPageTypeConfirm', 'GI.Gtk.Enums.AssistantPageTypeSummary' or
-- 'GI.Gtk.Enums.AssistantPageTypeProgress' to be correct.
-- 
-- The Cancel button will only be shown if the page isn’t “committed”.
-- See 'GI.Gtk.Objects.Assistant.assistantCommit' for details.
data AssistantPageType = 
      AssistantPageTypeContent
    -- ^ The page has regular contents. Both the
    --  Back and forward buttons will be shown.
    | AssistantPageTypeIntro
    -- ^ The page contains an introduction to the
    --  assistant task. Only the Forward button will be shown if there is a
    --   next page.
    | AssistantPageTypeConfirm
    -- ^ The page lets the user confirm or deny the
    --  changes. The Back and Apply buttons will be shown.
    | AssistantPageTypeSummary
    -- ^ The page informs the user of the changes
    --  done. Only the Close button will be shown.
    | AssistantPageTypeProgress
    -- ^ Used for tasks that take a long time to
    --  complete, blocks the assistant until the page is marked as complete.
    --   Only the back button will be shown.
    | AssistantPageTypeCustom
    -- ^ Used for when other page types are not
    --  appropriate. No buttons will be shown, and the application must
    --  add its own buttons through 'GI.Gtk.Objects.Assistant.assistantAddActionWidget'.
    | AnotherAssistantPageType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> AssistantPageType -> ShowS
[AssistantPageType] -> ShowS
AssistantPageType -> String
(Int -> AssistantPageType -> ShowS)
-> (AssistantPageType -> String)
-> ([AssistantPageType] -> ShowS)
-> Show AssistantPageType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AssistantPageType] -> ShowS
$cshowList :: [AssistantPageType] -> ShowS
show :: AssistantPageType -> String
$cshow :: AssistantPageType -> String
showsPrec :: Int -> AssistantPageType -> ShowS
$cshowsPrec :: Int -> AssistantPageType -> ShowS
Show, AssistantPageType -> AssistantPageType -> Bool
(AssistantPageType -> AssistantPageType -> Bool)
-> (AssistantPageType -> AssistantPageType -> Bool)
-> Eq AssistantPageType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AssistantPageType -> AssistantPageType -> Bool
$c/= :: AssistantPageType -> AssistantPageType -> Bool
== :: AssistantPageType -> AssistantPageType -> Bool
$c== :: AssistantPageType -> AssistantPageType -> Bool
Eq)

instance P.Enum AssistantPageType where
    fromEnum :: AssistantPageType -> Int
fromEnum AssistantPageTypeContent = 0
    fromEnum AssistantPageTypeIntro = 1
    fromEnum AssistantPageTypeConfirm = 2
    fromEnum AssistantPageTypeSummary = 3
    fromEnum AssistantPageTypeProgress = 4
    fromEnum AssistantPageTypeCustom = 5
    fromEnum (AnotherAssistantPageType k :: Int
k) = Int
k

    toEnum :: Int -> AssistantPageType
toEnum 0 = AssistantPageType
AssistantPageTypeContent
    toEnum 1 = AssistantPageType
AssistantPageTypeIntro
    toEnum 2 = AssistantPageType
AssistantPageTypeConfirm
    toEnum 3 = AssistantPageType
AssistantPageTypeSummary
    toEnum 4 = AssistantPageType
AssistantPageTypeProgress
    toEnum 5 = AssistantPageType
AssistantPageTypeCustom
    toEnum k :: Int
k = Int -> AssistantPageType
AnotherAssistantPageType Int
k

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

foreign import ccall "gtk_assistant_page_type_get_type" c_gtk_assistant_page_type_get_type :: 
    IO GType

instance BoxedEnum AssistantPageType where
    boxedEnumType :: AssistantPageType -> IO GType
boxedEnumType _ = IO GType
c_gtk_assistant_page_type_get_type

-- Enum ArrowType
-- | Used to indicate the direction in which an arrow should point.
data ArrowType = 
      ArrowTypeUp
    -- ^ Represents an upward pointing arrow.
    | ArrowTypeDown
    -- ^ Represents a downward pointing arrow.
    | ArrowTypeLeft
    -- ^ Represents a left pointing arrow.
    | ArrowTypeRight
    -- ^ Represents a right pointing arrow.
    | ArrowTypeNone
    -- ^ No arrow. Since 2.10.
    | AnotherArrowType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ArrowType -> ShowS
[ArrowType] -> ShowS
ArrowType -> String
(Int -> ArrowType -> ShowS)
-> (ArrowType -> String)
-> ([ArrowType] -> ShowS)
-> Show ArrowType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ArrowType] -> ShowS
$cshowList :: [ArrowType] -> ShowS
show :: ArrowType -> String
$cshow :: ArrowType -> String
showsPrec :: Int -> ArrowType -> ShowS
$cshowsPrec :: Int -> ArrowType -> ShowS
Show, ArrowType -> ArrowType -> Bool
(ArrowType -> ArrowType -> Bool)
-> (ArrowType -> ArrowType -> Bool) -> Eq ArrowType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ArrowType -> ArrowType -> Bool
$c/= :: ArrowType -> ArrowType -> Bool
== :: ArrowType -> ArrowType -> Bool
$c== :: ArrowType -> ArrowType -> Bool
Eq)

instance P.Enum ArrowType where
    fromEnum :: ArrowType -> Int
fromEnum ArrowTypeUp = 0
    fromEnum ArrowTypeDown = 1
    fromEnum ArrowTypeLeft = 2
    fromEnum ArrowTypeRight = 3
    fromEnum ArrowTypeNone = 4
    fromEnum (AnotherArrowType k :: Int
k) = Int
k

    toEnum :: Int -> ArrowType
toEnum 0 = ArrowType
ArrowTypeUp
    toEnum 1 = ArrowType
ArrowTypeDown
    toEnum 2 = ArrowType
ArrowTypeLeft
    toEnum 3 = ArrowType
ArrowTypeRight
    toEnum 4 = ArrowType
ArrowTypeNone
    toEnum k :: Int
k = Int -> ArrowType
AnotherArrowType Int
k

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

foreign import ccall "gtk_arrow_type_get_type" c_gtk_arrow_type_get_type :: 
    IO GType

instance BoxedEnum ArrowType where
    boxedEnumType :: ArrowType -> IO GType
boxedEnumType _ = IO GType
c_gtk_arrow_type_get_type

-- Enum ArrowPlacement
-- | Used to specify the placement of scroll arrows in scrolling menus.
data ArrowPlacement = 
      ArrowPlacementBoth
    -- ^ Place one arrow on each end of the menu.
    | ArrowPlacementStart
    -- ^ Place both arrows at the top of the menu.
    | ArrowPlacementEnd
    -- ^ Place both arrows at the bottom of the menu.
    | AnotherArrowPlacement Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ArrowPlacement -> ShowS
[ArrowPlacement] -> ShowS
ArrowPlacement -> String
(Int -> ArrowPlacement -> ShowS)
-> (ArrowPlacement -> String)
-> ([ArrowPlacement] -> ShowS)
-> Show ArrowPlacement
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ArrowPlacement] -> ShowS
$cshowList :: [ArrowPlacement] -> ShowS
show :: ArrowPlacement -> String
$cshow :: ArrowPlacement -> String
showsPrec :: Int -> ArrowPlacement -> ShowS
$cshowsPrec :: Int -> ArrowPlacement -> ShowS
Show, ArrowPlacement -> ArrowPlacement -> Bool
(ArrowPlacement -> ArrowPlacement -> Bool)
-> (ArrowPlacement -> ArrowPlacement -> Bool) -> Eq ArrowPlacement
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ArrowPlacement -> ArrowPlacement -> Bool
$c/= :: ArrowPlacement -> ArrowPlacement -> Bool
== :: ArrowPlacement -> ArrowPlacement -> Bool
$c== :: ArrowPlacement -> ArrowPlacement -> Bool
Eq)

instance P.Enum ArrowPlacement where
    fromEnum :: ArrowPlacement -> Int
fromEnum ArrowPlacementBoth = 0
    fromEnum ArrowPlacementStart = 1
    fromEnum ArrowPlacementEnd = 2
    fromEnum (AnotherArrowPlacement k :: Int
k) = Int
k

    toEnum :: Int -> ArrowPlacement
toEnum 0 = ArrowPlacement
ArrowPlacementBoth
    toEnum 1 = ArrowPlacement
ArrowPlacementStart
    toEnum 2 = ArrowPlacement
ArrowPlacementEnd
    toEnum k :: Int
k = Int -> ArrowPlacement
AnotherArrowPlacement Int
k

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

foreign import ccall "gtk_arrow_placement_get_type" c_gtk_arrow_placement_get_type :: 
    IO GType

instance BoxedEnum ArrowPlacement where
    boxedEnumType :: ArrowPlacement -> IO GType
boxedEnumType _ = IO GType
c_gtk_arrow_placement_get_type

-- Enum Align
-- | Controls how a widget deals with extra space in a single (x or y)
-- dimension.
-- 
-- Alignment only matters if the widget receives a “too large” allocation,
-- for example if you packed the widget with the t'GI.Gtk.Objects.Widget.Widget':@/expand/@
-- flag inside a t'GI.Gtk.Objects.Box.Box', then the widget might get extra space.  If
-- you have for example a 16x16 icon inside a 32x32 space, the icon
-- could be scaled and stretched, it could be centered, or it could be
-- positioned to one side of the space.
-- 
-- Note that in horizontal context /@gTKALIGNSTART@/ and /@gTKALIGNEND@/
-- are interpreted relative to text direction.
-- 
-- GTK_ALIGN_BASELINE support for it is optional for containers and widgets, and
-- it is only supported for vertical alignment.  When its not supported by
-- a child or a container it is treated as /@gTKALIGNFILL@/.
data Align = 
      AlignFill
    -- ^ stretch to fill all space if possible, center if
    --     no meaningful way to stretch
    | AlignStart
    -- ^ snap to left or top side, leaving space on right
    --     or bottom
    | AlignEnd
    -- ^ snap to right or bottom side, leaving space on left
    --     or top
    | AlignCenter
    -- ^ center natural width of widget inside the
    --     allocation
    | AlignBaseline
    -- ^ align the widget according to the baseline. Since 3.10.
    | AnotherAlign Int
    -- ^ Catch-all for unknown values
    deriving (Int -> Align -> ShowS
[Align] -> ShowS
Align -> String
(Int -> Align -> ShowS)
-> (Align -> String) -> ([Align] -> ShowS) -> Show Align
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Align] -> ShowS
$cshowList :: [Align] -> ShowS
show :: Align -> String
$cshow :: Align -> String
showsPrec :: Int -> Align -> ShowS
$cshowsPrec :: Int -> Align -> ShowS
Show, Align -> Align -> Bool
(Align -> Align -> Bool) -> (Align -> Align -> Bool) -> Eq Align
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Align -> Align -> Bool
$c/= :: Align -> Align -> Bool
== :: Align -> Align -> Bool
$c== :: Align -> Align -> Bool
Eq)

instance P.Enum Align where
    fromEnum :: Align -> Int
fromEnum AlignFill = 0
    fromEnum AlignStart = 1
    fromEnum AlignEnd = 2
    fromEnum AlignCenter = 3
    fromEnum AlignBaseline = 4
    fromEnum (AnotherAlign k :: Int
k) = Int
k

    toEnum :: Int -> Align
toEnum 0 = Align
AlignFill
    toEnum 1 = Align
AlignStart
    toEnum 2 = Align
AlignEnd
    toEnum 3 = Align
AlignCenter
    toEnum 4 = Align
AlignBaseline
    toEnum k :: Int
k = Int -> Align
AnotherAlign Int
k

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

foreign import ccall "gtk_align_get_type" c_gtk_align_get_type :: 
    IO GType

instance BoxedEnum Align where
    boxedEnumType :: Align -> IO GType
boxedEnumType _ = IO GType
c_gtk_align_get_type