-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria

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

module GI.Gtk.Enums
    ( 

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

    Align(..)                               ,


-- ** ArrowPlacement #enum:ArrowPlacement#

    ArrowPlacement(..)                      ,


-- ** ArrowType #enum:ArrowType#

    ArrowType(..)                           ,


-- ** AssistantPageType #enum:AssistantPageType#

    AssistantPageType(..)                   ,


-- ** BaselinePosition #enum:BaselinePosition#

    BaselinePosition(..)                    ,


-- ** BorderStyle #enum:BorderStyle#

    BorderStyle(..)                         ,


-- ** BuilderError #enum:BuilderError#

    BuilderError(..)                        ,
    catchBuilderError                       ,
    handleBuilderError                      ,


-- ** ButtonBoxStyle #enum:ButtonBoxStyle#

    ButtonBoxStyle(..)                      ,


-- ** ButtonRole #enum:ButtonRole#

    ButtonRole(..)                          ,


-- ** ButtonsType #enum:ButtonsType#

    ButtonsType(..)                         ,


-- ** CellRendererAccelMode #enum:CellRendererAccelMode#

    CellRendererAccelMode(..)               ,


-- ** CellRendererMode #enum:CellRendererMode#

    CellRendererMode(..)                    ,


-- ** CornerType #enum:CornerType#

    CornerType(..)                          ,


-- ** CssProviderError #enum:CssProviderError#

    CssProviderError(..)                    ,
    catchCssProviderError                   ,
    handleCssProviderError                  ,


-- ** CssSectionType #enum:CssSectionType#

    CssSectionType(..)                      ,


-- ** DeleteType #enum:DeleteType#

    DeleteType(..)                          ,


-- ** DirectionType #enum:DirectionType#

    DirectionType(..)                       ,


-- ** DragResult #enum:DragResult#

    DragResult(..)                          ,


-- ** EntryIconPosition #enum:EntryIconPosition#

    EntryIconPosition(..)                   ,


-- ** EventSequenceState #enum:EventSequenceState#

    EventSequenceState(..)                  ,


-- ** ExpanderStyle #enum:ExpanderStyle#

    ExpanderStyle(..)                       ,


-- ** FileChooserAction #enum:FileChooserAction#

    FileChooserAction(..)                   ,


-- ** FileChooserConfirmation #enum:FileChooserConfirmation#

    FileChooserConfirmation(..)             ,


-- ** FileChooserError #enum:FileChooserError#

    FileChooserError(..)                    ,
    catchFileChooserError                   ,
    handleFileChooserError                  ,


-- ** IMPreeditStyle #enum:IMPreeditStyle#

    IMPreeditStyle(..)                      ,


-- ** IMStatusStyle #enum:IMStatusStyle#

    IMStatusStyle(..)                       ,


-- ** IconSize #enum:IconSize#

    IconSize(..)                            ,


-- ** IconThemeError #enum:IconThemeError#

    IconThemeError(..)                      ,
    catchIconThemeError                     ,
    handleIconThemeError                    ,


-- ** IconViewDropPosition #enum:IconViewDropPosition#

    IconViewDropPosition(..)                ,


-- ** ImageType #enum:ImageType#

    ImageType(..)                           ,


-- ** InputPurpose #enum:InputPurpose#

    InputPurpose(..)                        ,


-- ** Justification #enum:Justification#

    Justification(..)                       ,


-- ** LevelBarMode #enum:LevelBarMode#

    LevelBarMode(..)                        ,


-- ** License #enum:License#

    License(..)                             ,


-- ** MenuDirectionType #enum:MenuDirectionType#

    MenuDirectionType(..)                   ,


-- ** MessageType #enum:MessageType#

    MessageType(..)                         ,


-- ** MovementStep #enum:MovementStep#

    MovementStep(..)                        ,


-- ** NotebookTab #enum:NotebookTab#

    NotebookTab(..)                         ,


-- ** NumberUpLayout #enum:NumberUpLayout#

    NumberUpLayout(..)                      ,


-- ** Orientation #enum:Orientation#

    Orientation(..)                         ,


-- ** PackDirection #enum:PackDirection#

    PackDirection(..)                       ,


-- ** PackType #enum:PackType#

    PackType(..)                            ,


-- ** PadActionType #enum:PadActionType#

    PadActionType(..)                       ,


-- ** PageOrientation #enum:PageOrientation#

    PageOrientation(..)                     ,


-- ** PageSet #enum:PageSet#

    PageSet(..)                             ,


-- ** PanDirection #enum:PanDirection#

    PanDirection(..)                        ,


-- ** PathPriorityType #enum:PathPriorityType#

    PathPriorityType(..)                    ,


-- ** PathType #enum:PathType#

    PathType(..)                            ,


-- ** PolicyType #enum:PolicyType#

    PolicyType(..)                          ,


-- ** PopoverConstraint #enum:PopoverConstraint#

    PopoverConstraint(..)                   ,


-- ** PositionType #enum:PositionType#

    PositionType(..)                        ,


-- ** PrintDuplex #enum:PrintDuplex#

    PrintDuplex(..)                         ,


-- ** PrintError #enum:PrintError#

    PrintError(..)                          ,
    catchPrintError                         ,
    handlePrintError                        ,


-- ** PrintOperationAction #enum:PrintOperationAction#

    PrintOperationAction(..)                ,


-- ** PrintOperationResult #enum:PrintOperationResult#

    PrintOperationResult(..)                ,


-- ** PrintPages #enum:PrintPages#

    PrintPages(..)                          ,


-- ** PrintQuality #enum:PrintQuality#

    PrintQuality(..)                        ,


-- ** PrintStatus #enum:PrintStatus#

    PrintStatus(..)                         ,


-- ** PropagationPhase #enum:PropagationPhase#

    PropagationPhase(..)                    ,


-- ** RcTokenType #enum:RcTokenType#

    RcTokenType(..)                         ,


-- ** RecentChooserError #enum:RecentChooserError#

    RecentChooserError(..)                  ,
    catchRecentChooserError                 ,
    handleRecentChooserError                ,


-- ** RecentManagerError #enum:RecentManagerError#

    RecentManagerError(..)                  ,
    catchRecentManagerError                 ,
    handleRecentManagerError                ,


-- ** RecentSortType #enum:RecentSortType#

    RecentSortType(..)                      ,


-- ** ReliefStyle #enum:ReliefStyle#

    ReliefStyle(..)                         ,


-- ** ResizeMode #enum:ResizeMode#

    ResizeMode(..)                          ,


-- ** ResponseType #enum:ResponseType#

    ResponseType(..)                        ,


-- ** RevealerTransitionType #enum:RevealerTransitionType#

    RevealerTransitionType(..)              ,


-- ** ScrollStep #enum:ScrollStep#

    ScrollStep(..)                          ,


-- ** ScrollType #enum:ScrollType#

    ScrollType(..)                          ,


-- ** ScrollablePolicy #enum:ScrollablePolicy#

    ScrollablePolicy(..)                    ,


-- ** SelectionMode #enum:SelectionMode#

    SelectionMode(..)                       ,


-- ** SensitivityType #enum:SensitivityType#

    SensitivityType(..)                     ,


-- ** ShadowType #enum:ShadowType#

    ShadowType(..)                          ,


-- ** ShortcutType #enum:ShortcutType#

    ShortcutType(..)                        ,


-- ** SizeGroupMode #enum:SizeGroupMode#

    SizeGroupMode(..)                       ,


-- ** SizeRequestMode #enum:SizeRequestMode#

    SizeRequestMode(..)                     ,


-- ** SortType #enum:SortType#

    SortType(..)                            ,


-- ** SpinButtonUpdatePolicy #enum:SpinButtonUpdatePolicy#

    SpinButtonUpdatePolicy(..)              ,


-- ** SpinType #enum:SpinType#

    SpinType(..)                            ,


-- ** StackTransitionType #enum:StackTransitionType#

    StackTransitionType(..)                 ,


-- ** StateType #enum:StateType#

    StateType(..)                           ,


-- ** TextBufferTargetInfo #enum:TextBufferTargetInfo#

    TextBufferTargetInfo(..)                ,


-- ** TextDirection #enum:TextDirection#

    TextDirection(..)                       ,


-- ** TextExtendSelection #enum:TextExtendSelection#

    TextExtendSelection(..)                 ,


-- ** TextViewLayer #enum:TextViewLayer#

    TextViewLayer(..)                       ,


-- ** TextWindowType #enum:TextWindowType#

    TextWindowType(..)                      ,


-- ** ToolbarSpaceStyle #enum:ToolbarSpaceStyle#

    ToolbarSpaceStyle(..)                   ,


-- ** ToolbarStyle #enum:ToolbarStyle#

    ToolbarStyle(..)                        ,


-- ** TreeViewColumnSizing #enum:TreeViewColumnSizing#

    TreeViewColumnSizing(..)                ,


-- ** TreeViewDropPosition #enum:TreeViewDropPosition#

    TreeViewDropPosition(..)                ,


-- ** TreeViewGridLines #enum:TreeViewGridLines#

    TreeViewGridLines(..)                   ,


-- ** Unit #enum:Unit#

    Unit(..)                                ,


-- ** WidgetHelpType #enum:WidgetHelpType#

    WidgetHelpType(..)                      ,


-- ** WindowPosition #enum:WindowPosition#

    WindowPosition(..)                      ,


-- ** WindowType #enum:WindowType#

    WindowType(..)                          ,


-- ** WrapMode #enum:WrapMode#

    WrapMode(..)                            ,




    ) where

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

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


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

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

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

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

foreign import ccall "gtk_wrap_mode_get_type" c_gtk_wrap_mode_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_window_type_get_type" c_gtk_window_type_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_window_position_get_type" c_gtk_window_position_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_widget_help_type_get_type" c_gtk_widget_help_type_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_unit_get_type" c_gtk_unit_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_tree_view_grid_lines_get_type" c_gtk_tree_view_grid_lines_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_tree_view_drop_position_get_type" c_gtk_tree_view_drop_position_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_tree_view_column_sizing_get_type" c_gtk_tree_view_column_sizing_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_toolbar_style_get_type" c_gtk_toolbar_style_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_toolbar_space_style_get_type" c_gtk_toolbar_space_style_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_text_window_type_get_type" c_gtk_text_window_type_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_text_view_layer_get_type" c_gtk_text_view_layer_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_text_extend_selection_get_type" c_gtk_text_extend_selection_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_text_direction_get_type" c_gtk_text_direction_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_text_buffer_target_info_get_type" c_gtk_text_buffer_target_info_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_state_type_get_type" c_gtk_state_type_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_stack_transition_type_get_type" c_gtk_stack_transition_type_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_spin_type_get_type" c_gtk_spin_type_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_spin_button_update_policy_get_type" c_gtk_spin_button_update_policy_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_sort_type_get_type" c_gtk_sort_type_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_size_request_mode_get_type" c_gtk_size_request_mode_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_size_group_mode_get_type" c_gtk_size_group_mode_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_shortcut_type_get_type" c_gtk_shortcut_type_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_shadow_type_get_type" c_gtk_shadow_type_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_sensitivity_type_get_type" c_gtk_sensitivity_type_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_selection_mode_get_type" c_gtk_selection_mode_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_scrollable_policy_get_type" c_gtk_scrollable_policy_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_scroll_type_get_type" c_gtk_scroll_type_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_scroll_step_get_type" c_gtk_scroll_step_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_revealer_transition_type_get_type" c_gtk_revealer_transition_type_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_response_type_get_type" c_gtk_response_type_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_resize_mode_get_type" c_gtk_resize_mode_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_relief_style_get_type" c_gtk_relief_style_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_recent_sort_type_get_type" c_gtk_recent_sort_type_get_type :: 
    IO GType

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

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

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

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

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

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

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

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

foreign import ccall "gtk_recent_manager_error_get_type" c_gtk_recent_manager_error_get_type :: 
    IO GType

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

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

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

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

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

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

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

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

foreign import ccall "gtk_recent_chooser_error_get_type" c_gtk_recent_chooser_error_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_rc_token_type_get_type" c_gtk_rc_token_type_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_propagation_phase_get_type" c_gtk_propagation_phase_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_print_status_get_type" c_gtk_print_status_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_print_quality_get_type" c_gtk_print_quality_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_print_pages_get_type" c_gtk_print_pages_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_print_operation_result_get_type" c_gtk_print_operation_result_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_print_operation_action_get_type" c_gtk_print_operation_action_get_type :: 
    IO GType

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

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

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

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

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

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

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

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

foreign import ccall "gtk_print_error_get_type" c_gtk_print_error_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_print_duplex_get_type" c_gtk_print_duplex_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_position_type_get_type" c_gtk_position_type_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_popover_constraint_get_type" c_gtk_popover_constraint_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_policy_type_get_type" c_gtk_policy_type_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_path_type_get_type" c_gtk_path_type_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_path_priority_type_get_type" c_gtk_path_priority_type_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_pan_direction_get_type" c_gtk_pan_direction_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_page_set_get_type" c_gtk_page_set_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_page_orientation_get_type" c_gtk_page_orientation_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_pad_action_type_get_type" c_gtk_pad_action_type_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_pack_type_get_type" c_gtk_pack_type_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_pack_direction_get_type" c_gtk_pack_direction_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_orientation_get_type" c_gtk_orientation_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_number_up_layout_get_type" c_gtk_number_up_layout_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_notebook_tab_get_type" c_gtk_notebook_tab_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_movement_step_get_type" c_gtk_movement_step_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_message_type_get_type" c_gtk_message_type_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_menu_direction_type_get_type" c_gtk_menu_direction_type_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_license_get_type" c_gtk_license_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_level_bar_mode_get_type" c_gtk_level_bar_mode_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_justification_get_type" c_gtk_justification_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_input_purpose_get_type" c_gtk_input_purpose_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_image_type_get_type" c_gtk_image_type_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_icon_view_drop_position_get_type" c_gtk_icon_view_drop_position_get_type :: 
    IO GType

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

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

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

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

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

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

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

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

foreign import ccall "gtk_icon_theme_error_get_type" c_gtk_icon_theme_error_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_icon_size_get_type" c_gtk_icon_size_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_im_status_style_get_type" c_gtk_im_status_style_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_im_preedit_style_get_type" c_gtk_im_preedit_style_get_type :: 
    IO GType

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

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

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

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

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

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

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

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

foreign import ccall "gtk_file_chooser_error_get_type" c_gtk_file_chooser_error_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_file_chooser_confirmation_get_type" c_gtk_file_chooser_confirmation_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_file_chooser_action_get_type" c_gtk_file_chooser_action_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_expander_style_get_type" c_gtk_expander_style_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_event_sequence_state_get_type" c_gtk_event_sequence_state_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_entry_icon_position_get_type" c_gtk_entry_icon_position_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_drag_result_get_type" c_gtk_drag_result_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_direction_type_get_type" c_gtk_direction_type_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_delete_type_get_type" c_gtk_delete_type_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_css_section_type_get_type" c_gtk_css_section_type_get_type :: 
    IO GType

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

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

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

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

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

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

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

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

foreign import ccall "gtk_css_provider_error_get_type" c_gtk_css_provider_error_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_corner_type_get_type" c_gtk_corner_type_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_cell_renderer_mode_get_type" c_gtk_cell_renderer_mode_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_cell_renderer_accel_mode_get_type" c_gtk_cell_renderer_accel_mode_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_buttons_type_get_type" c_gtk_buttons_type_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_button_role_get_type" c_gtk_button_role_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_button_box_style_get_type" c_gtk_button_box_style_get_type :: 
    IO GType

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

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

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

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

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

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

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

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

foreign import ccall "gtk_builder_error_get_type" c_gtk_builder_error_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_border_style_get_type" c_gtk_border_style_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_baseline_position_get_type" c_gtk_baseline_position_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_assistant_page_type_get_type" c_gtk_assistant_page_type_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_arrow_type_get_type" c_gtk_arrow_type_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_arrow_placement_get_type" c_gtk_arrow_placement_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_align_get_type" c_gtk_align_get_type :: 
    IO GType

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