gi-gtk-3.0.28: GI/Gtk/Enums.hs

{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)
-}

#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
       && !defined(__HADDOCK_VERSION__))

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

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

    toEnum 0 = WrapModeNone
    toEnum 1 = WrapModeChar
    toEnum 2 = WrapModeWord
    toEnum 3 = WrapModeWordChar
    toEnum k = AnotherWrapMode k

instance P.Ord WrapMode where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_wrap_mode_get_type" c_gtk_wrap_mode_get_type :: 
    IO GType

instance BoxedEnum WrapMode where
    boxedEnumType _ = c_gtk_wrap_mode_get_type

-- Enum WindowType
{- |
A '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 '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 (Show, Eq)

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

    toEnum 0 = WindowTypeToplevel
    toEnum 1 = WindowTypePopup
    toEnum k = AnotherWindowType k

instance P.Ord WindowType where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_window_type_get_type" c_gtk_window_type_get_type :: 
    IO GType

instance BoxedEnum WindowType where
    boxedEnumType _ = 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 (Show, Eq)

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

    toEnum 0 = WindowPositionNone
    toEnum 1 = WindowPositionCenter
    toEnum 2 = WindowPositionMouse
    toEnum 3 = WindowPositionCenterAlways
    toEnum 4 = WindowPositionCenterOnParent
    toEnum k = AnotherWindowPosition k

instance P.Ord WindowPosition where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_window_position_get_type" c_gtk_window_position_get_type :: 
    IO GType

instance BoxedEnum WindowPosition where
    boxedEnumType _ = c_gtk_window_position_get_type

-- Enum WidgetHelpType
{- |
Kinds of widget-specific help. Used by the ::show-help signal.
-}
data WidgetHelpType = 
      WidgetHelpTypeTooltip
    {- ^
    Tooltip.
    -}
    | WidgetHelpTypeWhatsThis
    {- ^
    What’s this.
    -}
    | AnotherWidgetHelpType Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

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

    toEnum 0 = WidgetHelpTypeTooltip
    toEnum 1 = WidgetHelpTypeWhatsThis
    toEnum k = AnotherWidgetHelpType k

instance P.Ord WidgetHelpType where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_widget_help_type_get_type" c_gtk_widget_help_type_get_type :: 
    IO GType

instance BoxedEnum WidgetHelpType where
    boxedEnumType _ = 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 (Show, Eq)

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

    toEnum 0 = UnitNone
    toEnum 1 = UnitPoints
    toEnum 2 = UnitInch
    toEnum 3 = UnitMm
    toEnum k = AnotherUnit k

instance P.Ord Unit where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_unit_get_type" c_gtk_unit_get_type :: 
    IO GType

instance BoxedEnum Unit where
    boxedEnumType _ = 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 (Show, Eq)

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

    toEnum 0 = TreeViewGridLinesNone
    toEnum 1 = TreeViewGridLinesHorizontal
    toEnum 2 = TreeViewGridLinesVertical
    toEnum 3 = TreeViewGridLinesBoth
    toEnum k = AnotherTreeViewGridLines k

instance P.Ord TreeViewGridLines where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum 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 _ = 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 (Show, Eq)

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

    toEnum 0 = TreeViewDropPositionBefore
    toEnum 1 = TreeViewDropPositionAfter
    toEnum 2 = TreeViewDropPositionIntoOrBefore
    toEnum 3 = TreeViewDropPositionIntoOrAfter
    toEnum k = AnotherTreeViewDropPosition k

instance P.Ord TreeViewDropPosition where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum 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 _ = 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 (Show, Eq)

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

    toEnum 0 = TreeViewColumnSizingGrowOnly
    toEnum 1 = TreeViewColumnSizingAutosize
    toEnum 2 = TreeViewColumnSizingFixed
    toEnum k = AnotherTreeViewColumnSizing k

instance P.Ord TreeViewColumnSizing where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum 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 _ = c_gtk_tree_view_column_sizing_get_type

-- Enum ToolbarStyle
{- |
Used to customize the appearance of a '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 (Show, Eq)

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

    toEnum 0 = ToolbarStyleIcons
    toEnum 1 = ToolbarStyleText
    toEnum 2 = ToolbarStyleBoth
    toEnum 3 = ToolbarStyleBothHoriz
    toEnum k = AnotherToolbarStyle k

instance P.Ord ToolbarStyle where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_toolbar_style_get_type" c_gtk_toolbar_style_get_type :: 
    IO GType

instance BoxedEnum ToolbarStyle where
    boxedEnumType _ = 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 (Show, Eq)

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

    toEnum 0 = ToolbarSpaceStyleEmpty
    toEnum 1 = ToolbarSpaceStyleLine
    toEnum k = AnotherToolbarSpaceStyle k

instance P.Ord ToolbarSpaceStyle where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_toolbar_space_style_get_type" c_gtk_toolbar_space_style_get_type :: 
    IO GType

instance BoxedEnum ToolbarSpaceStyle where
    boxedEnumType _ = c_gtk_toolbar_space_style_get_type

-- Enum TextWindowType
{- |
Used to reference the parts of '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 (Show, Eq)

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

    toEnum 0 = TextWindowTypePrivate
    toEnum 1 = TextWindowTypeWidget
    toEnum 2 = TextWindowTypeText
    toEnum 3 = TextWindowTypeLeft
    toEnum 4 = TextWindowTypeRight
    toEnum 5 = TextWindowTypeTop
    toEnum 6 = TextWindowTypeBottom
    toEnum k = AnotherTextWindowType k

instance P.Ord TextWindowType where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_text_window_type_get_type" c_gtk_text_window_type_get_type :: 
    IO GType

instance BoxedEnum TextWindowType where
    boxedEnumType _ = c_gtk_text_window_type_get_type

-- Enum TextViewLayer
{- |
Used to reference the layers of 'GI.Gtk.Objects.TextView.TextView' for the purpose of customized
drawing with the ::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 (Show, Eq)

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

    toEnum 0 = TextViewLayerBelow
    toEnum 1 = TextViewLayerAbove
    toEnum 2 = TextViewLayerBelowText
    toEnum 3 = TextViewLayerAboveText
    toEnum k = AnotherTextViewLayer k

instance P.Ord TextViewLayer where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_text_view_layer_get_type" c_gtk_text_view_layer_get_type :: 
    IO GType

instance BoxedEnum TextViewLayer where
    boxedEnumType _ = c_gtk_text_view_layer_get_type

-- Enum TextExtendSelection
{- |
Granularity types that extend the text selection. Use the
'GI.Gtk.Objects.TextView.TextView'::@/extend-selection/@ 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 (Show, Eq)

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

    toEnum 0 = TextExtendSelectionWord
    toEnum 1 = TextExtendSelectionLine
    toEnum k = AnotherTextExtendSelection k

instance P.Ord TextExtendSelection where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_text_extend_selection_get_type" c_gtk_text_extend_selection_get_type :: 
    IO GType

instance BoxedEnum TextExtendSelection where
    boxedEnumType _ = 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 (Show, Eq)

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

    toEnum 0 = TextDirectionNone
    toEnum 1 = TextDirectionLtr
    toEnum 2 = TextDirectionRtl
    toEnum k = AnotherTextDirection k

instance P.Ord TextDirection where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_text_direction_get_type" c_gtk_text_direction_get_type :: 
    IO GType

instance BoxedEnum TextDirection where
    boxedEnumType _ = 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 (Show, Eq)

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

    toEnum -1 = TextBufferTargetInfoBufferContents
    toEnum -2 = TextBufferTargetInfoRichText
    toEnum -3 = TextBufferTargetInfoText
    toEnum k = AnotherTextBufferTargetInfo k

instance P.Ord TextBufferTargetInfo where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum 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 _ = 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 'GI.Gtk.Flags.StateFlags'."] #-}
{- |
This type indicates the current state of a widget; the state determines how
the widget is drawn. The 'GI.Gtk.Enums.StateType' enumeration is also used to
identify different colors in a '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 'True' nor 'False',
                             or buttons requiring the user attention.
    -}
    | StateTypeFocused
    {- ^
    The widget has the keyboard focus.
    -}
    | AnotherStateType Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

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

    toEnum 0 = StateTypeNormal
    toEnum 1 = StateTypeActive
    toEnum 2 = StateTypePrelight
    toEnum 3 = StateTypeSelected
    toEnum 4 = StateTypeInsensitive
    toEnum 5 = StateTypeInconsistent
    toEnum 6 = StateTypeFocused
    toEnum k = AnotherStateType k

instance P.Ord StateType where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_state_type_get_type" c_gtk_state_type_get_type :: 
    IO GType

instance BoxedEnum StateType where
    boxedEnumType _ = c_gtk_state_type_get_type

-- Enum StackTransitionType
{- |
These enumeration values describe the possible transitions
between pages in a '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 (Show, Eq)

instance P.Enum StackTransitionType where
    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) = k

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

instance P.Ord StackTransitionType where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_stack_transition_type_get_type" c_gtk_stack_transition_type_get_type :: 
    IO GType

instance BoxedEnum StackTransitionType where
    boxedEnumType _ = 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 (Show, Eq)

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

    toEnum 0 = SpinTypeStepForward
    toEnum 1 = SpinTypeStepBackward
    toEnum 2 = SpinTypePageForward
    toEnum 3 = SpinTypePageBackward
    toEnum 4 = SpinTypeHome
    toEnum 5 = SpinTypeEnd
    toEnum 6 = SpinTypeUserDefined
    toEnum k = AnotherSpinType k

instance P.Ord SpinType where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_spin_type_get_type" c_gtk_spin_type_get_type :: 
    IO GType

instance BoxedEnum SpinType where
    boxedEnumType _ = 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 'GI.Gtk.Objects.SpinButton.SpinButton', the value is
        always displayed
    -}
    | SpinButtonUpdatePolicyIfValid
    {- ^
    When refreshing your '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 (Show, Eq)

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

    toEnum 0 = SpinButtonUpdatePolicyAlways
    toEnum 1 = SpinButtonUpdatePolicyIfValid
    toEnum k = AnotherSpinButtonUpdatePolicy k

instance P.Ord SpinButtonUpdatePolicy where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum 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 _ = 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 (Show, Eq)

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

    toEnum 0 = SortTypeAscending
    toEnum 1 = SortTypeDescending
    toEnum k = AnotherSortType k

instance P.Ord SortType where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_sort_type_get_type" c_gtk_sort_type_get_type :: 
    IO GType

instance BoxedEnum SortType where
    boxedEnumType _ = 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 (Show, Eq)

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

    toEnum 0 = SizeRequestModeHeightForWidth
    toEnum 1 = SizeRequestModeWidthForHeight
    toEnum 2 = SizeRequestModeConstantSize
    toEnum k = AnotherSizeRequestMode k

instance P.Ord SizeRequestMode where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_size_request_mode_get_type" c_gtk_size_request_mode_get_type :: 
    IO GType

instance BoxedEnum SizeRequestMode where
    boxedEnumType _ = 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 (Show, Eq)

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

    toEnum 0 = SizeGroupModeNone
    toEnum 1 = SizeGroupModeHorizontal
    toEnum 2 = SizeGroupModeVertical
    toEnum 3 = SizeGroupModeBoth
    toEnum k = AnotherSizeGroupMode k

instance P.Ord SizeGroupMode where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_size_group_mode_get_type" c_gtk_size_group_mode_get_type :: 
    IO GType

instance BoxedEnum SizeGroupMode where
    boxedEnumType _ = 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 '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 'GI.Gtk.Objects.ShortcutsShortcut.ShortcutsShortcut':@/icon/@ property will be
      used.
    -}
    | AnotherShortcutType Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum ShortcutType where
    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) = k

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

instance P.Ord ShortcutType where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_shortcut_type_get_type" c_gtk_shortcut_type_get_type :: 
    IO GType

instance BoxedEnum ShortcutType where
    boxedEnumType _ = c_gtk_shortcut_type_get_type

-- Enum ShadowType
{- |
Used to change the appearance of an outline typically provided by a '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 (Show, Eq)

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

    toEnum 0 = ShadowTypeNone
    toEnum 1 = ShadowTypeIn
    toEnum 2 = ShadowTypeOut
    toEnum 3 = ShadowTypeEtchedIn
    toEnum 4 = ShadowTypeEtchedOut
    toEnum k = AnotherShadowType k

instance P.Ord ShadowType where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_shadow_type_get_type" c_gtk_shadow_type_get_type :: 
    IO GType

instance BoxedEnum ShadowType where
    boxedEnumType _ = 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 (Show, Eq)

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

    toEnum 0 = SensitivityTypeAuto
    toEnum 1 = SensitivityTypeOn
    toEnum 2 = SensitivityTypeOff
    toEnum k = AnotherSensitivityType k

instance P.Ord SensitivityType where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_sensitivity_type_get_type" c_gtk_sensitivity_type_get_type :: 
    IO GType

instance BoxedEnum SensitivityType where
    boxedEnumType _ = 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 (Show, Eq)

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

    toEnum 0 = SelectionModeNone
    toEnum 1 = SelectionModeSingle
    toEnum 2 = SelectionModeBrowse
    toEnum 3 = SelectionModeMultiple
    toEnum k = AnotherSelectionMode k

instance P.Ord SelectionMode where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_selection_mode_get_type" c_gtk_selection_mode_get_type :: 
    IO GType

instance BoxedEnum SelectionMode where
    boxedEnumType _ = 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 (Show, Eq)

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

    toEnum 0 = ScrollablePolicyMinimum
    toEnum 1 = ScrollablePolicyNatural
    toEnum k = AnotherScrollablePolicy k

instance P.Ord ScrollablePolicy where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_scrollable_policy_get_type" c_gtk_scrollable_policy_get_type :: 
    IO GType

instance BoxedEnum ScrollablePolicy where
    boxedEnumType _ = 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 (Show, Eq)

instance P.Enum ScrollType where
    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) = k

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

instance P.Ord ScrollType where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_scroll_type_get_type" c_gtk_scroll_type_get_type :: 
    IO GType

instance BoxedEnum ScrollType where
    boxedEnumType _ = 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 (Show, Eq)

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

    toEnum 0 = ScrollStepSteps
    toEnum 1 = ScrollStepPages
    toEnum 2 = ScrollStepEnds
    toEnum 3 = ScrollStepHorizontalSteps
    toEnum 4 = ScrollStepHorizontalPages
    toEnum 5 = ScrollStepHorizontalEnds
    toEnum k = AnotherScrollStep k

instance P.Ord ScrollStep where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_scroll_step_get_type" c_gtk_scroll_step_get_type :: 
    IO GType

instance BoxedEnum ScrollStep where
    boxedEnumType _ = c_gtk_scroll_step_get_type

-- Enum RevealerTransitionType
{- |
These enumeration values describe the possible transitions
when the child of a '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 (Show, Eq)

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

    toEnum 0 = RevealerTransitionTypeNone
    toEnum 1 = RevealerTransitionTypeCrossfade
    toEnum 2 = RevealerTransitionTypeSlideRight
    toEnum 3 = RevealerTransitionTypeSlideLeft
    toEnum 4 = RevealerTransitionTypeSlideUp
    toEnum 5 = RevealerTransitionTypeSlideDown
    toEnum k = AnotherRevealerTransitionType k

instance P.Ord RevealerTransitionType where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_revealer_transition_type_get_type" c_gtk_revealer_transition_type_get_type :: 
    IO GType

instance BoxedEnum RevealerTransitionType where
    boxedEnumType _ = 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 (Show, Eq)

instance P.Enum ResponseType where
    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) = k

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

instance P.Ord ResponseType where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_response_type_get_type" c_gtk_response_type_get_type :: 
    IO GType

instance BoxedEnum ResponseType where
    boxedEnumType _ = 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 (Show, Eq)

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

    toEnum 0 = ResizeModeParent
    toEnum 1 = ResizeModeQueue
    toEnum 2 = ResizeModeImmediate
    toEnum k = AnotherResizeMode k

instance P.Ord ResizeMode where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_resize_mode_get_type" c_gtk_resize_mode_get_type :: 
    IO GType

instance BoxedEnum ResizeMode where
    boxedEnumType _ = c_gtk_resize_mode_get_type

-- Enum ReliefStyle
{- |
Indicated the relief to be drawn around a '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 (Show, Eq)

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

    toEnum 0 = ReliefStyleNormal
    toEnum 1 = ReliefStyleHalf
    toEnum 2 = ReliefStyleNone
    toEnum k = AnotherReliefStyle k

instance P.Ord ReliefStyle where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_relief_style_get_type" c_gtk_relief_style_get_type :: 
    IO GType

instance BoxedEnum ReliefStyle where
    boxedEnumType _ = 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 (Show, Eq)

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

    toEnum 0 = RecentSortTypeNone
    toEnum 1 = RecentSortTypeMru
    toEnum 2 = RecentSortTypeLru
    toEnum 3 = RecentSortTypeCustom
    toEnum k = AnotherRecentSortType k

instance P.Ord RecentSortType where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_recent_sort_type_get_type" c_gtk_recent_sort_type_get_type :: 
    IO GType

instance BoxedEnum RecentSortType where
    boxedEnumType _ = c_gtk_recent_sort_type_get_type

-- Enum RecentManagerError
{- |
Error codes for '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 (Show, Eq)

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

    toEnum 0 = RecentManagerErrorNotFound
    toEnum 1 = RecentManagerErrorInvalidUri
    toEnum 2 = RecentManagerErrorInvalidEncoding
    toEnum 3 = RecentManagerErrorNotRegistered
    toEnum 4 = RecentManagerErrorRead
    toEnum 5 = RecentManagerErrorWrite
    toEnum 6 = RecentManagerErrorUnknown
    toEnum k = AnotherRecentManagerError k

instance P.Ord RecentManagerError where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

instance GErrorClass RecentManagerError where
    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 = 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 = handleGErrorJustDomain

foreign import ccall "gtk_recent_manager_error_get_type" c_gtk_recent_manager_error_get_type :: 
    IO GType

instance BoxedEnum RecentManagerError where
    boxedEnumType _ = c_gtk_recent_manager_error_get_type

-- Enum RecentChooserError
{- |
These identify the various errors that can occur while calling
'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 (Show, Eq)

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

    toEnum 0 = RecentChooserErrorNotFound
    toEnum 1 = RecentChooserErrorInvalidUri
    toEnum k = AnotherRecentChooserError k

instance P.Ord RecentChooserError where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

instance GErrorClass RecentChooserError where
    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 = 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 = handleGErrorJustDomain

foreign import ccall "gtk_recent_chooser_error_get_type" c_gtk_recent_chooser_error_get_type :: 
    IO GType

instance BoxedEnum RecentChooserError where
    boxedEnumType _ = c_gtk_recent_chooser_error_get_type

-- Enum RcTokenType
{-# DEPRECATED RcTokenType ["(Since version 3.0)","Use 'GI.Gtk.Objects.CssProvider.CssProvider' instead."] #-}
{- |
The '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 (Show, Eq)

instance P.Enum RcTokenType where
    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) = k

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

instance P.Ord RcTokenType where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_rc_token_type_get_type" c_gtk_rc_token_type_get_type :: 
    IO GType

instance BoxedEnum RcTokenType where
    boxedEnumType _ = c_gtk_rc_token_type_get_type

-- Enum PropagationPhase
{- |
Describes the stage at which events are fed into a '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 (Show, Eq)

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

    toEnum 0 = PropagationPhaseNone
    toEnum 1 = PropagationPhaseCapture
    toEnum 2 = PropagationPhaseBubble
    toEnum 3 = PropagationPhaseTarget
    toEnum k = AnotherPropagationPhase k

instance P.Ord PropagationPhase where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_propagation_phase_get_type" c_gtk_propagation_phase_get_type :: 
    IO GType

instance BoxedEnum PropagationPhase where
    boxedEnumType _ = 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 (Show, Eq)

instance P.Enum PrintStatus where
    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) = k

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

instance P.Ord PrintStatus where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_print_status_get_type" c_gtk_print_status_get_type :: 
    IO GType

instance BoxedEnum PrintStatus where
    boxedEnumType _ = 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 (Show, Eq)

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

    toEnum 0 = PrintQualityLow
    toEnum 1 = PrintQualityNormal
    toEnum 2 = PrintQualityHigh
    toEnum 3 = PrintQualityDraft
    toEnum k = AnotherPrintQuality k

instance P.Ord PrintQuality where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_print_quality_get_type" c_gtk_print_quality_get_type :: 
    IO GType

instance BoxedEnum PrintQuality where
    boxedEnumType _ = 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 (Show, Eq)

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

    toEnum 0 = PrintPagesAll
    toEnum 1 = PrintPagesCurrent
    toEnum 2 = PrintPagesRanges
    toEnum 3 = PrintPagesSelection
    toEnum k = AnotherPrintPages k

instance P.Ord PrintPages where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_print_pages_get_type" c_gtk_print_pages_get_type :: 
    IO GType

instance BoxedEnum PrintPages where
    boxedEnumType _ = 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 (Show, Eq)

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

    toEnum 0 = PrintOperationResultError
    toEnum 1 = PrintOperationResultApply
    toEnum 2 = PrintOperationResultCancel
    toEnum 3 = PrintOperationResultInProgress
    toEnum k = AnotherPrintOperationResult k

instance P.Ord PrintOperationResult where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_print_operation_result_get_type" c_gtk_print_operation_result_get_type :: 
    IO GType

instance BoxedEnum PrintOperationResult where
    boxedEnumType _ = 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 (Show, Eq)

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

    toEnum 0 = PrintOperationActionPrintDialog
    toEnum 1 = PrintOperationActionPrint
    toEnum 2 = PrintOperationActionPreview
    toEnum 3 = PrintOperationActionExport
    toEnum k = AnotherPrintOperationAction k

instance P.Ord PrintOperationAction where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_print_operation_action_get_type" c_gtk_print_operation_action_get_type :: 
    IO GType

instance BoxedEnum PrintOperationAction where
    boxedEnumType _ = 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 (Show, Eq)

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

    toEnum 0 = PrintErrorGeneral
    toEnum 1 = PrintErrorInternalError
    toEnum 2 = PrintErrorNomem
    toEnum 3 = PrintErrorInvalidFile
    toEnum k = AnotherPrintError k

instance P.Ord PrintError where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

instance GErrorClass PrintError where
    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 = 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 = handleGErrorJustDomain

foreign import ccall "gtk_print_error_get_type" c_gtk_print_error_get_type :: 
    IO GType

instance BoxedEnum PrintError where
    boxedEnumType _ = 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 (Show, Eq)

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

    toEnum 0 = PrintDuplexSimplex
    toEnum 1 = PrintDuplexHorizontal
    toEnum 2 = PrintDuplexVertical
    toEnum k = AnotherPrintDuplex k

instance P.Ord PrintDuplex where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_print_duplex_get_type" c_gtk_print_duplex_get_type :: 
    IO GType

instance BoxedEnum PrintDuplex where
    boxedEnumType _ = 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 'GI.Gtk.Objects.Notebook.Notebook', the handle of a 'GI.Gtk.Objects.HandleBox.HandleBox' or the label of a
'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 (Show, Eq)

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

    toEnum 0 = PositionTypeLeft
    toEnum 1 = PositionTypeRight
    toEnum 2 = PositionTypeTop
    toEnum 3 = PositionTypeBottom
    toEnum k = AnotherPositionType k

instance P.Ord PositionType where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_position_type_get_type" c_gtk_position_type_get_type :: 
    IO GType

instance BoxedEnum PositionType where
    boxedEnumType _ = 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 (Show, Eq)

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

    toEnum 0 = PopoverConstraintNone
    toEnum 1 = PopoverConstraintWindow
    toEnum k = AnotherPopoverConstraint k

instance P.Ord PopoverConstraint where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_popover_constraint_get_type" c_gtk_popover_constraint_get_type :: 
    IO GType

instance BoxedEnum PopoverConstraint where
    boxedEnumType _ = 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 '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 (Show, Eq)

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

    toEnum 0 = PolicyTypeAlways
    toEnum 1 = PolicyTypeAutomatic
    toEnum 2 = PolicyTypeNever
    toEnum 3 = PolicyTypeExternal
    toEnum k = AnotherPolicyType k

instance P.Ord PolicyType where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_policy_type_get_type" c_gtk_policy_type_get_type :: 
    IO GType

instance BoxedEnum PolicyType where
    boxedEnumType _ = 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 (Show, Eq)

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

    toEnum 0 = PathTypeWidget
    toEnum 1 = PathTypeWidgetClass
    toEnum 2 = PathTypeClass
    toEnum k = AnotherPathType k

instance P.Ord PathType where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_path_type_get_type" c_gtk_path_type_get_type :: 
    IO GType

instance BoxedEnum PathType where
    boxedEnumType _ = 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 (Show, Eq)

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

    toEnum 0 = PathPriorityTypeLowest
    toEnum 4 = PathPriorityTypeGtk
    toEnum 8 = PathPriorityTypeApplication
    toEnum 10 = PathPriorityTypeTheme
    toEnum 12 = PathPriorityTypeRc
    toEnum 15 = PathPriorityTypeHighest
    toEnum k = AnotherPathPriorityType k

instance P.Ord PathPriorityType where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_path_priority_type_get_type" c_gtk_path_priority_type_get_type :: 
    IO GType

instance BoxedEnum PathPriorityType where
    boxedEnumType _ = c_gtk_path_priority_type_get_type

-- Enum PanDirection
{- |
Describes the panning direction of a '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 (Show, Eq)

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

    toEnum 0 = PanDirectionLeft
    toEnum 1 = PanDirectionRight
    toEnum 2 = PanDirectionUp
    toEnum 3 = PanDirectionDown
    toEnum k = AnotherPanDirection k

instance P.Ord PanDirection where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_pan_direction_get_type" c_gtk_pan_direction_get_type :: 
    IO GType

instance BoxedEnum PanDirection where
    boxedEnumType _ = 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 (Show, Eq)

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

    toEnum 0 = PageSetAll
    toEnum 1 = PageSetEven
    toEnum 2 = PageSetOdd
    toEnum k = AnotherPageSet k

instance P.Ord PageSet where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_page_set_get_type" c_gtk_page_set_get_type :: 
    IO GType

instance BoxedEnum PageSet where
    boxedEnumType _ = 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 (Show, Eq)

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

    toEnum 0 = PageOrientationPortrait
    toEnum 1 = PageOrientationLandscape
    toEnum 2 = PageOrientationReversePortrait
    toEnum 3 = PageOrientationReverseLandscape
    toEnum k = AnotherPageOrientation k

instance P.Ord PageOrientation where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_page_orientation_get_type" c_gtk_page_orientation_get_type :: 
    IO GType

instance BoxedEnum PageOrientation where
    boxedEnumType _ = 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 (Show, Eq)

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

    toEnum 0 = PadActionTypeButton
    toEnum 1 = PadActionTypeRing
    toEnum 2 = PadActionTypeStrip
    toEnum k = AnotherPadActionType k

instance P.Ord PadActionType where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_pad_action_type_get_type" c_gtk_pad_action_type_get_type :: 
    IO GType

instance BoxedEnum PadActionType where
    boxedEnumType _ = c_gtk_pad_action_type_get_type

-- Enum PackType
{- |
Represents the packing location 'GI.Gtk.Objects.Box.Box' children. (See: 'GI.Gtk.Objects.VBox.VBox',
'GI.Gtk.Objects.HBox.HBox', and '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 (Show, Eq)

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

    toEnum 0 = PackTypeStart
    toEnum 1 = PackTypeEnd
    toEnum k = AnotherPackType k

instance P.Ord PackType where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_pack_type_get_type" c_gtk_pack_type_get_type :: 
    IO GType

instance BoxedEnum PackType where
    boxedEnumType _ = 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 (Show, Eq)

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

    toEnum 0 = PackDirectionLtr
    toEnum 1 = PackDirectionRtl
    toEnum 2 = PackDirectionTtb
    toEnum 3 = PackDirectionBtt
    toEnum k = AnotherPackDirection k

instance P.Ord PackDirection where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_pack_direction_get_type" c_gtk_pack_direction_get_type :: 
    IO GType

instance BoxedEnum PackDirection where
    boxedEnumType _ = 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 'GI.Gtk.Objects.Toolbar.Toolbar' or
'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 (Show, Eq)

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

    toEnum 0 = OrientationHorizontal
    toEnum 1 = OrientationVertical
    toEnum k = AnotherOrientation k

instance P.Ord Orientation where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_orientation_get_type" c_gtk_orientation_get_type :: 
    IO GType

instance BoxedEnum Orientation where
    boxedEnumType _ = 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 (Show, Eq)

instance P.Enum NumberUpLayout where
    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) = k

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

instance P.Ord NumberUpLayout where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_number_up_layout_get_type" c_gtk_number_up_layout_get_type :: 
    IO GType

instance BoxedEnum NumberUpLayout where
    boxedEnumType _ = 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 (Show, Eq)

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

    toEnum 0 = NotebookTabFirst
    toEnum 1 = NotebookTabLast
    toEnum k = AnotherNotebookTab k

instance P.Ord NotebookTab where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_notebook_tab_get_type" c_gtk_notebook_tab_get_type :: 
    IO GType

instance BoxedEnum NotebookTab where
    boxedEnumType _ = 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 (Show, Eq)

instance P.Enum MovementStep where
    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) = k

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

instance P.Ord MovementStep where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_movement_step_get_type" c_gtk_movement_step_get_type :: 
    IO GType

instance BoxedEnum MovementStep where
    boxedEnumType _ = 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 (Show, Eq)

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

    toEnum 0 = MessageTypeInfo
    toEnum 1 = MessageTypeWarning
    toEnum 2 = MessageTypeQuestion
    toEnum 3 = MessageTypeError
    toEnum 4 = MessageTypeOther
    toEnum k = AnotherMessageType k

instance P.Ord MessageType where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_message_type_get_type" c_gtk_message_type_get_type :: 
    IO GType

instance BoxedEnum MessageType where
    boxedEnumType _ = 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 (Show, Eq)

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

    toEnum 0 = MenuDirectionTypeParent
    toEnum 1 = MenuDirectionTypeChild
    toEnum 2 = MenuDirectionTypeNext
    toEnum 3 = MenuDirectionTypePrev
    toEnum k = AnotherMenuDirectionType k

instance P.Ord MenuDirectionType where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_menu_direction_type_get_type" c_gtk_menu_direction_type_get_type :: 
    IO GType

instance BoxedEnum MenuDirectionType where
    boxedEnumType _ = 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 (Show, Eq)

instance P.Enum License where
    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) = k

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

instance P.Ord License where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_license_get_type" c_gtk_license_get_type :: 
    IO GType

instance BoxedEnum License where
    boxedEnumType _ = c_gtk_license_get_type

-- Enum LevelBarMode
{- |
Describes how '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 (Show, Eq)

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

    toEnum 0 = LevelBarModeContinuous
    toEnum 1 = LevelBarModeDiscrete
    toEnum k = AnotherLevelBarMode k

instance P.Ord LevelBarMode where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_level_bar_mode_get_type" c_gtk_level_bar_mode_get_type :: 
    IO GType

instance BoxedEnum LevelBarMode where
    boxedEnumType _ = c_gtk_level_bar_mode_get_type

-- Enum Justification
{- |
Used for justifying the text inside a 'GI.Gtk.Objects.Label.Label' widget. (See also
'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 (Show, Eq)

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

    toEnum 0 = JustificationLeft
    toEnum 1 = JustificationRight
    toEnum 2 = JustificationCenter
    toEnum 3 = JustificationFill
    toEnum k = AnotherJustification k

instance P.Ord Justification where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_justification_get_type" c_gtk_justification_get_type :: 
    IO GType

instance BoxedEnum Justification where
    boxedEnumType _ = 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 (Show, Eq)

instance P.Enum InputPurpose where
    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) = k

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

instance P.Ord InputPurpose where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_input_purpose_get_type" c_gtk_input_purpose_get_type :: 
    IO GType

instance BoxedEnum InputPurpose where
    boxedEnumType _ = c_gtk_input_purpose_get_type

-- Enum ImageType
{- |
Describes the image data representation used by a '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 'Nothing' values.
-}
data ImageType = 
      ImageTypeEmpty
    {- ^
    there is no image displayed by the widget
    -}
    | ImageTypePixbuf
    {- ^
    the widget contains a 'GI.GdkPixbuf.Objects.Pixbuf.Pixbuf'
    -}
    | ImageTypeStock
    {- ^
    the widget contains a [stock item name][gtkstock]
    -}
    | ImageTypeIconSet
    {- ^
    the widget contains a 'GI.Gtk.Structs.IconSet.IconSet'
    -}
    | ImageTypeAnimation
    {- ^
    the widget contains a '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 'GI.Gio.Interfaces.Icon.Icon'.
     This image type was added in GTK+ 2.14
    -}
    | ImageTypeSurface
    {- ^
    the widget contains a 'GI.Cairo.Structs.Surface.Surface'.
     This image type was added in GTK+ 3.10
    -}
    | AnotherImageType Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum ImageType where
    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) = k

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

instance P.Ord ImageType where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_image_type_get_type" c_gtk_image_type_get_type :: 
    IO GType

instance BoxedEnum ImageType where
    boxedEnumType _ = 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 (Show, Eq)

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

    toEnum 0 = IconViewDropPositionNoDrop
    toEnum 1 = IconViewDropPositionDropInto
    toEnum 2 = IconViewDropPositionDropLeft
    toEnum 3 = IconViewDropPositionDropRight
    toEnum 4 = IconViewDropPositionDropAbove
    toEnum 5 = IconViewDropPositionDropBelow
    toEnum k = AnotherIconViewDropPosition k

instance P.Ord IconViewDropPosition where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum 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 _ = 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 (Show, Eq)

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

    toEnum 0 = IconThemeErrorNotFound
    toEnum 1 = IconThemeErrorFailed
    toEnum k = AnotherIconThemeError k

instance P.Ord IconThemeError where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

instance GErrorClass IconThemeError where
    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 = 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 = handleGErrorJustDomain

foreign import ccall "gtk_icon_theme_error_get_type" c_gtk_icon_theme_error_get_type :: 
    IO GType

instance BoxedEnum IconThemeError where
    boxedEnumType _ = 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 (Show, Eq)

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

    toEnum 0 = IconSizeInvalid
    toEnum 1 = IconSizeMenu
    toEnum 2 = IconSizeSmallToolbar
    toEnum 3 = IconSizeLargeToolbar
    toEnum 4 = IconSizeButton
    toEnum 5 = IconSizeDnd
    toEnum 6 = IconSizeDialog
    toEnum k = AnotherIconSize k

instance P.Ord IconSize where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_icon_size_get_type" c_gtk_icon_size_get_type :: 
    IO GType

instance BoxedEnum IconSize where
    boxedEnumType _ = c_gtk_icon_size_get_type

-- Enum IMStatusStyle
{-# DEPRECATED IMStatusStyle ["(Since version 3.10)"] #-}
{- |
Style for input method status. See also
'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 (Show, Eq)

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

    toEnum 0 = IMStatusStyleNothing
    toEnum 1 = IMStatusStyleCallback
    toEnum 2 = IMStatusStyleNone
    toEnum k = AnotherIMStatusStyle k

instance P.Ord IMStatusStyle where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_im_status_style_get_type" c_gtk_im_status_style_get_type :: 
    IO GType

instance BoxedEnum IMStatusStyle where
    boxedEnumType _ = c_gtk_im_status_style_get_type

-- Enum IMPreeditStyle
{-# DEPRECATED IMPreeditStyle ["(Since version 3.10)"] #-}
{- |
Style for input method preedit. See also
'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 (Show, Eq)

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

    toEnum 0 = IMPreeditStyleNothing
    toEnum 1 = IMPreeditStyleCallback
    toEnum 2 = IMPreeditStyleNone
    toEnum k = AnotherIMPreeditStyle k

instance P.Ord IMPreeditStyle where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_im_preedit_style_get_type" c_gtk_im_preedit_style_get_type :: 
    IO GType

instance BoxedEnum IMPreeditStyle where
    boxedEnumType _ = c_gtk_im_preedit_style_get_type

-- Enum FileChooserError
{- |
These identify the various errors that can occur while calling
'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 (Show, Eq)

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

    toEnum 0 = FileChooserErrorNonexistent
    toEnum 1 = FileChooserErrorBadFilename
    toEnum 2 = FileChooserErrorAlreadyExists
    toEnum 3 = FileChooserErrorIncompleteHostname
    toEnum k = AnotherFileChooserError k

instance P.Ord FileChooserError where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

instance GErrorClass FileChooserError where
    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 = 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 = handleGErrorJustDomain

foreign import ccall "gtk_file_chooser_error_get_type" c_gtk_file_chooser_error_get_type :: 
    IO GType

instance BoxedEnum FileChooserError where
    boxedEnumType _ = c_gtk_file_chooser_error_get_type

-- Enum FileChooserConfirmation
{- |
Used as a return value of handlers for the
'GI.Gtk.Interfaces.FileChooser.FileChooser'::@/confirm-overwrite/@ signal of a '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 (Show, Eq)

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

    toEnum 0 = FileChooserConfirmationConfirm
    toEnum 1 = FileChooserConfirmationAcceptFilename
    toEnum 2 = FileChooserConfirmationSelectAgain
    toEnum k = AnotherFileChooserConfirmation k

instance P.Ord FileChooserConfirmation where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_file_chooser_confirmation_get_type" c_gtk_file_chooser_confirmation_get_type :: 
    IO GType

instance BoxedEnum FileChooserConfirmation where
    boxedEnumType _ = c_gtk_file_chooser_confirmation_get_type

-- Enum FileChooserAction
{- |
Describes whether a '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 (Show, Eq)

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

    toEnum 0 = FileChooserActionOpen
    toEnum 1 = FileChooserActionSave
    toEnum 2 = FileChooserActionSelectFolder
    toEnum 3 = FileChooserActionCreateFolder
    toEnum k = AnotherFileChooserAction k

instance P.Ord FileChooserAction where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_file_chooser_action_get_type" c_gtk_file_chooser_action_get_type :: 
    IO GType

instance BoxedEnum FileChooserAction where
    boxedEnumType _ = c_gtk_file_chooser_action_get_type

-- Enum ExpanderStyle
{- |
Used to specify the style of the expanders drawn by a '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 (Show, Eq)

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

    toEnum 0 = ExpanderStyleCollapsed
    toEnum 1 = ExpanderStyleSemiCollapsed
    toEnum 2 = ExpanderStyleSemiExpanded
    toEnum 3 = ExpanderStyleExpanded
    toEnum k = AnotherExpanderStyle k

instance P.Ord ExpanderStyle where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_expander_style_get_type" c_gtk_expander_style_get_type :: 
    IO GType

instance BoxedEnum ExpanderStyle where
    boxedEnumType _ = c_gtk_expander_style_get_type

-- Enum EventSequenceState
{- |
Describes the state of a 'GI.Gdk.Structs.EventSequence.EventSequence' in a '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 (Show, Eq)

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

    toEnum 0 = EventSequenceStateNone
    toEnum 1 = EventSequenceStateClaimed
    toEnum 2 = EventSequenceStateDenied
    toEnum k = AnotherEventSequenceState k

instance P.Ord EventSequenceState where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_event_sequence_state_get_type" c_gtk_event_sequence_state_get_type :: 
    IO GType

instance BoxedEnum EventSequenceState where
    boxedEnumType _ = 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 (Show, Eq)

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

    toEnum 0 = EntryIconPositionPrimary
    toEnum 1 = EntryIconPositionSecondary
    toEnum k = AnotherEntryIconPosition k

instance P.Ord EntryIconPosition where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_entry_icon_position_get_type" c_gtk_entry_icon_position_get_type :: 
    IO GType

instance BoxedEnum EntryIconPosition where
    boxedEnumType _ = 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
'GI.Gtk.Objects.Widget.Widget'::@/drag-failed/@ 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 (Show, Eq)

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

    toEnum 0 = DragResultSuccess
    toEnum 1 = DragResultNoTarget
    toEnum 2 = DragResultUserCancelled
    toEnum 3 = DragResultTimeoutExpired
    toEnum 4 = DragResultGrabBroken
    toEnum 5 = DragResultError
    toEnum k = AnotherDragResult k

instance P.Ord DragResult where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_drag_result_get_type" c_gtk_drag_result_get_type :: 
    IO GType

instance BoxedEnum DragResult where
    boxedEnumType _ = 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 (Show, Eq)

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

    toEnum 0 = DirectionTypeTabForward
    toEnum 1 = DirectionTypeTabBackward
    toEnum 2 = DirectionTypeUp
    toEnum 3 = DirectionTypeDown
    toEnum 4 = DirectionTypeLeft
    toEnum 5 = DirectionTypeRight
    toEnum k = AnotherDirectionType k

instance P.Ord DirectionType where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_direction_type_get_type" c_gtk_direction_type_get_type :: 
    IO GType

instance BoxedEnum DirectionType where
    boxedEnumType _ = c_gtk_direction_type_get_type

-- Enum DeleteType
{- |
See also: 'GI.Gtk.Objects.Entry.Entry'::@/delete-from-cursor/@.
-}
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 (Show, Eq)

instance P.Enum DeleteType where
    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) = k

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

instance P.Ord DeleteType where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_delete_type_get_type" c_gtk_delete_type_get_type :: 
    IO GType

instance BoxedEnum DeleteType where
    boxedEnumType _ = 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 '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 (Show, Eq)

instance P.Enum CssSectionType where
    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) = k

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

instance P.Ord CssSectionType where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_css_section_type_get_type" c_gtk_css_section_type_get_type :: 
    IO GType

instance BoxedEnum CssSectionType where
    boxedEnumType _ = 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 (Show, Eq)

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

    toEnum 0 = CssProviderErrorFailed
    toEnum 1 = CssProviderErrorSyntax
    toEnum 2 = CssProviderErrorImport
    toEnum 3 = CssProviderErrorName
    toEnum 4 = CssProviderErrorDeprecated
    toEnum 5 = CssProviderErrorUnknownValue
    toEnum k = AnotherCssProviderError k

instance P.Ord CssProviderError where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

instance GErrorClass CssProviderError where
    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 = 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 = handleGErrorJustDomain

foreign import ccall "gtk_css_provider_error_get_type" c_gtk_css_provider_error_get_type :: 
    IO GType

instance BoxedEnum CssProviderError where
    boxedEnumType _ = c_gtk_css_provider_error_get_type

-- Enum CornerType
{- |
Specifies which corner a child widget should be placed in when packed into
a '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 (Show, Eq)

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

    toEnum 0 = CornerTypeTopLeft
    toEnum 1 = CornerTypeBottomLeft
    toEnum 2 = CornerTypeTopRight
    toEnum 3 = CornerTypeBottomRight
    toEnum k = AnotherCornerType k

instance P.Ord CornerType where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_corner_type_get_type" c_gtk_corner_type_get_type :: 
    IO GType

instance BoxedEnum CornerType where
    boxedEnumType _ = 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 (Show, Eq)

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

    toEnum 0 = CellRendererModeInert
    toEnum 1 = CellRendererModeActivatable
    toEnum 2 = CellRendererModeEditable
    toEnum k = AnotherCellRendererMode k

instance P.Ord CellRendererMode where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_cell_renderer_mode_get_type" c_gtk_cell_renderer_mode_get_type :: 
    IO GType

instance BoxedEnum CellRendererMode where
    boxedEnumType _ = 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 (Show, Eq)

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

    toEnum 0 = CellRendererAccelModeGtk
    toEnum 1 = CellRendererAccelModeOther
    toEnum k = AnotherCellRendererAccelMode k

instance P.Ord CellRendererAccelMode where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum 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 _ = 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 (Show, Eq)

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

    toEnum 0 = ButtonsTypeNone
    toEnum 1 = ButtonsTypeOk
    toEnum 2 = ButtonsTypeClose
    toEnum 3 = ButtonsTypeCancel
    toEnum 4 = ButtonsTypeYesNo
    toEnum 5 = ButtonsTypeOkCancel
    toEnum k = AnotherButtonsType k

instance P.Ord ButtonsType where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_buttons_type_get_type" c_gtk_buttons_type_get_type :: 
    IO GType

instance BoxedEnum ButtonsType where
    boxedEnumType _ = c_gtk_buttons_type_get_type

-- Enum ButtonRole
{- |
The role specifies the desired appearance of a '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 (Show, Eq)

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

    toEnum 0 = ButtonRoleNormal
    toEnum 1 = ButtonRoleCheck
    toEnum 2 = ButtonRoleRadio
    toEnum k = AnotherButtonRole k

instance P.Ord ButtonRole where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_button_role_get_type" c_gtk_button_role_get_type :: 
    IO GType

instance BoxedEnum ButtonRole where
    boxedEnumType _ = c_gtk_button_role_get_type

-- Enum ButtonBoxStyle
{- |
Used to dictate the style that a '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 (Show, Eq)

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

    toEnum 1 = ButtonBoxStyleSpread
    toEnum 2 = ButtonBoxStyleEdge
    toEnum 3 = ButtonBoxStyleStart
    toEnum 4 = ButtonBoxStyleEnd
    toEnum 5 = ButtonBoxStyleCenter
    toEnum 6 = ButtonBoxStyleExpand
    toEnum k = AnotherButtonBoxStyle k

instance P.Ord ButtonBoxStyle where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_button_box_style_get_type" c_gtk_button_box_style_get_type :: 
    IO GType

instance BoxedEnum ButtonBoxStyle where
    boxedEnumType _ = c_gtk_button_box_style_get_type

-- Enum BuilderError
{- |
Error codes that identify various errors that can occur while using
'GI.Gtk.Objects.Builder.Builder'.
-}
data BuilderError = 
      BuilderErrorInvalidTypeFunction
    {- ^
    A type-func attribute didn’t name
     a function that returns a 'GType'.
    -}
    | BuilderErrorUnhandledTag
    {- ^
    The input contained a tag that 'GI.Gtk.Objects.Builder.Builder'
     can’t handle.
    -}
    | BuilderErrorMissingAttribute
    {- ^
    An attribute that is required by
     'GI.Gtk.Objects.Builder.Builder' was missing.
    -}
    | BuilderErrorInvalidAttribute
    {- ^
    'GI.Gtk.Objects.Builder.Builder' found an attribute that
     it doesn’t understand.
    -}
    | BuilderErrorInvalidTag
    {- ^
    'GI.Gtk.Objects.Builder.Builder' found a tag that
     it doesn’t understand.
    -}
    | BuilderErrorMissingPropertyValue
    {- ^
    A required property value was
     missing.
    -}
    | BuilderErrorInvalidValue
    {- ^
    '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 (Show, Eq)

instance P.Enum BuilderError where
    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) = k

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

instance P.Ord BuilderError where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

instance GErrorClass BuilderError where
    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 = 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 = handleGErrorJustDomain

foreign import ccall "gtk_builder_error_get_type" c_gtk_builder_error_get_type :: 
    IO GType

instance BoxedEnum BuilderError where
    boxedEnumType _ = 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 (Show, Eq)

instance P.Enum BorderStyle where
    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) = k

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

instance P.Ord BorderStyle where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_border_style_get_type" c_gtk_border_style_get_type :: 
    IO GType

instance BoxedEnum BorderStyle where
    boxedEnumType _ = 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
'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 (Show, Eq)

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

    toEnum 0 = BaselinePositionTop
    toEnum 1 = BaselinePositionCenter
    toEnum 2 = BaselinePositionBottom
    toEnum k = AnotherBaselinePosition k

instance P.Ord BaselinePosition where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_baseline_position_get_type" c_gtk_baseline_position_get_type :: 
    IO GType

instance BoxedEnum BaselinePosition where
    boxedEnumType _ = c_gtk_baseline_position_get_type

-- Enum AssistantPageType
{- |
An enum for determining the page role inside the '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 (Show, Eq)

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

    toEnum 0 = AssistantPageTypeContent
    toEnum 1 = AssistantPageTypeIntro
    toEnum 2 = AssistantPageTypeConfirm
    toEnum 3 = AssistantPageTypeSummary
    toEnum 4 = AssistantPageTypeProgress
    toEnum 5 = AssistantPageTypeCustom
    toEnum k = AnotherAssistantPageType k

instance P.Ord AssistantPageType where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_assistant_page_type_get_type" c_gtk_assistant_page_type_get_type :: 
    IO GType

instance BoxedEnum AssistantPageType where
    boxedEnumType _ = 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 (Show, Eq)

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

    toEnum 0 = ArrowTypeUp
    toEnum 1 = ArrowTypeDown
    toEnum 2 = ArrowTypeLeft
    toEnum 3 = ArrowTypeRight
    toEnum 4 = ArrowTypeNone
    toEnum k = AnotherArrowType k

instance P.Ord ArrowType where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_arrow_type_get_type" c_gtk_arrow_type_get_type :: 
    IO GType

instance BoxedEnum ArrowType where
    boxedEnumType _ = 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 (Show, Eq)

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

    toEnum 0 = ArrowPlacementBoth
    toEnum 1 = ArrowPlacementStart
    toEnum 2 = ArrowPlacementEnd
    toEnum k = AnotherArrowPlacement k

instance P.Ord ArrowPlacement where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_arrow_placement_get_type" c_gtk_arrow_placement_get_type :: 
    IO GType

instance BoxedEnum ArrowPlacement where
    boxedEnumType _ = 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 'GI.Gtk.Objects.Widget.Widget':@/expand/@
flag inside a '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 (Show, Eq)

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

    toEnum 0 = AlignFill
    toEnum 1 = AlignStart
    toEnum 2 = AlignEnd
    toEnum 3 = AlignCenter
    toEnum 4 = AlignBaseline
    toEnum k = AnotherAlign k

instance P.Ord Align where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "gtk_align_get_type" c_gtk_align_get_type :: 
    IO GType

instance BoxedEnum Align where
    boxedEnumType _ = c_gtk_align_get_type