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

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

module GI.Gtk.Enums
    ( 

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

    Align(..)                               ,


-- ** ArrowPlacement #enum:ArrowPlacement#

    ArrowPlacement(..)                      ,


-- ** ArrowType #enum:ArrowType#

    ArrowType(..)                           ,


-- ** AssistantPageType #enum:AssistantPageType#

    AssistantPageType(..)                   ,


-- ** BaselinePosition #enum:BaselinePosition#

    BaselinePosition(..)                    ,


-- ** BorderStyle #enum:BorderStyle#

    BorderStyle(..)                         ,


-- ** BuilderError #enum:BuilderError#

    BuilderError(..)                        ,
    catchBuilderError                       ,
    handleBuilderError                      ,


-- ** ButtonBoxStyle #enum:ButtonBoxStyle#

    ButtonBoxStyle(..)                      ,


-- ** ButtonRole #enum:ButtonRole#

    ButtonRole(..)                          ,


-- ** ButtonsType #enum:ButtonsType#

    ButtonsType(..)                         ,


-- ** CellRendererAccelMode #enum:CellRendererAccelMode#

    CellRendererAccelMode(..)               ,


-- ** CellRendererMode #enum:CellRendererMode#

    CellRendererMode(..)                    ,


-- ** CornerType #enum:CornerType#

    CornerType(..)                          ,


-- ** CssProviderError #enum:CssProviderError#

    CssProviderError(..)                    ,
    catchCssProviderError                   ,
    handleCssProviderError                  ,


-- ** CssSectionType #enum:CssSectionType#

    CssSectionType(..)                      ,


-- ** DeleteType #enum:DeleteType#

    DeleteType(..)                          ,


-- ** DirectionType #enum:DirectionType#

    DirectionType(..)                       ,


-- ** DragResult #enum:DragResult#

    DragResult(..)                          ,


-- ** EntryIconPosition #enum:EntryIconPosition#

    EntryIconPosition(..)                   ,


-- ** EventSequenceState #enum:EventSequenceState#

    EventSequenceState(..)                  ,


-- ** ExpanderStyle #enum:ExpanderStyle#

    ExpanderStyle(..)                       ,


-- ** FileChooserAction #enum:FileChooserAction#

    FileChooserAction(..)                   ,


-- ** FileChooserConfirmation #enum:FileChooserConfirmation#

    FileChooserConfirmation(..)             ,


-- ** FileChooserError #enum:FileChooserError#

    FileChooserError(..)                    ,
    catchFileChooserError                   ,
    handleFileChooserError                  ,


-- ** IMPreeditStyle #enum:IMPreeditStyle#

    IMPreeditStyle(..)                      ,


-- ** IMStatusStyle #enum:IMStatusStyle#

    IMStatusStyle(..)                       ,


-- ** IconSize #enum:IconSize#

    IconSize(..)                            ,


-- ** IconThemeError #enum:IconThemeError#

    IconThemeError(..)                      ,
    catchIconThemeError                     ,
    handleIconThemeError                    ,


-- ** IconViewDropPosition #enum:IconViewDropPosition#

    IconViewDropPosition(..)                ,


-- ** ImageType #enum:ImageType#

    ImageType(..)                           ,


-- ** InputPurpose #enum:InputPurpose#

    InputPurpose(..)                        ,


-- ** Justification #enum:Justification#

    Justification(..)                       ,


-- ** LevelBarMode #enum:LevelBarMode#

    LevelBarMode(..)                        ,


-- ** License #enum:License#

    License(..)                             ,


-- ** MenuDirectionType #enum:MenuDirectionType#

    MenuDirectionType(..)                   ,


-- ** MessageType #enum:MessageType#

    MessageType(..)                         ,


-- ** MovementStep #enum:MovementStep#

    MovementStep(..)                        ,


-- ** NotebookTab #enum:NotebookTab#

    NotebookTab(..)                         ,


-- ** NumberUpLayout #enum:NumberUpLayout#

    NumberUpLayout(..)                      ,


-- ** Orientation #enum:Orientation#

    Orientation(..)                         ,


-- ** PackDirection #enum:PackDirection#

    PackDirection(..)                       ,


-- ** PackType #enum:PackType#

    PackType(..)                            ,


-- ** PadActionType #enum:PadActionType#

    PadActionType(..)                       ,


-- ** PageOrientation #enum:PageOrientation#

    PageOrientation(..)                     ,


-- ** PageSet #enum:PageSet#

    PageSet(..)                             ,


-- ** PanDirection #enum:PanDirection#

    PanDirection(..)                        ,


-- ** PathPriorityType #enum:PathPriorityType#

    PathPriorityType(..)                    ,


-- ** PathType #enum:PathType#

    PathType(..)                            ,


-- ** PolicyType #enum:PolicyType#

    PolicyType(..)                          ,


-- ** PopoverConstraint #enum:PopoverConstraint#

    PopoverConstraint(..)                   ,


-- ** PositionType #enum:PositionType#

    PositionType(..)                        ,


-- ** PrintDuplex #enum:PrintDuplex#

    PrintDuplex(..)                         ,


-- ** PrintError #enum:PrintError#

    PrintError(..)                          ,
    catchPrintError                         ,
    handlePrintError                        ,


-- ** PrintOperationAction #enum:PrintOperationAction#

    PrintOperationAction(..)                ,


-- ** PrintOperationResult #enum:PrintOperationResult#

    PrintOperationResult(..)                ,


-- ** PrintPages #enum:PrintPages#

    PrintPages(..)                          ,


-- ** PrintQuality #enum:PrintQuality#

    PrintQuality(..)                        ,


-- ** PrintStatus #enum:PrintStatus#

    PrintStatus(..)                         ,


-- ** PropagationPhase #enum:PropagationPhase#

    PropagationPhase(..)                    ,


-- ** RcTokenType #enum:RcTokenType#

    RcTokenType(..)                         ,


-- ** RecentChooserError #enum:RecentChooserError#

    RecentChooserError(..)                  ,
    catchRecentChooserError                 ,
    handleRecentChooserError                ,


-- ** RecentManagerError #enum:RecentManagerError#

    RecentManagerError(..)                  ,
    catchRecentManagerError                 ,
    handleRecentManagerError                ,


-- ** RecentSortType #enum:RecentSortType#

    RecentSortType(..)                      ,


-- ** ReliefStyle #enum:ReliefStyle#

    ReliefStyle(..)                         ,


-- ** ResizeMode #enum:ResizeMode#

    ResizeMode(..)                          ,


-- ** ResponseType #enum:ResponseType#

    ResponseType(..)                        ,


-- ** RevealerTransitionType #enum:RevealerTransitionType#

    RevealerTransitionType(..)              ,


-- ** ScrollStep #enum:ScrollStep#

    ScrollStep(..)                          ,


-- ** ScrollType #enum:ScrollType#

    ScrollType(..)                          ,


-- ** ScrollablePolicy #enum:ScrollablePolicy#

    ScrollablePolicy(..)                    ,


-- ** SelectionMode #enum:SelectionMode#

    SelectionMode(..)                       ,


-- ** SensitivityType #enum:SensitivityType#

    SensitivityType(..)                     ,


-- ** ShadowType #enum:ShadowType#

    ShadowType(..)                          ,


-- ** ShortcutType #enum:ShortcutType#

    ShortcutType(..)                        ,


-- ** SizeGroupMode #enum:SizeGroupMode#

    SizeGroupMode(..)                       ,


-- ** SizeRequestMode #enum:SizeRequestMode#

    SizeRequestMode(..)                     ,


-- ** SortType #enum:SortType#

    SortType(..)                            ,


-- ** SpinButtonUpdatePolicy #enum:SpinButtonUpdatePolicy#

    SpinButtonUpdatePolicy(..)              ,


-- ** SpinType #enum:SpinType#

    SpinType(..)                            ,


-- ** StackTransitionType #enum:StackTransitionType#

    StackTransitionType(..)                 ,


-- ** StateType #enum:StateType#

    StateType(..)                           ,


-- ** TextBufferTargetInfo #enum:TextBufferTargetInfo#

    TextBufferTargetInfo(..)                ,


-- ** TextDirection #enum:TextDirection#

    TextDirection(..)                       ,


-- ** TextExtendSelection #enum:TextExtendSelection#

    TextExtendSelection(..)                 ,


-- ** TextViewLayer #enum:TextViewLayer#

    TextViewLayer(..)                       ,


-- ** TextWindowType #enum:TextWindowType#

    TextWindowType(..)                      ,


-- ** ToolbarSpaceStyle #enum:ToolbarSpaceStyle#

    ToolbarSpaceStyle(..)                   ,


-- ** ToolbarStyle #enum:ToolbarStyle#

    ToolbarStyle(..)                        ,


-- ** TreeViewColumnSizing #enum:TreeViewColumnSizing#

    TreeViewColumnSizing(..)                ,


-- ** TreeViewDropPosition #enum:TreeViewDropPosition#

    TreeViewDropPosition(..)                ,


-- ** TreeViewGridLines #enum:TreeViewGridLines#

    TreeViewGridLines(..)                   ,


-- ** Unit #enum:Unit#

    Unit(..)                                ,


-- ** WidgetHelpType #enum:WidgetHelpType#

    WidgetHelpType(..)                      ,


-- ** WindowPosition #enum:WindowPosition#

    WindowPosition(..)                      ,


-- ** WindowType #enum:WindowType#

    WindowType(..)                          ,


-- ** WrapMode #enum:WrapMode#

    WrapMode(..)                            ,




    ) where

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

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


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

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

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

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

foreign import ccall "gtk_wrap_mode_get_type" c_gtk_wrap_mode_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_window_type_get_type" c_gtk_window_type_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_window_position_get_type" c_gtk_window_position_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_widget_help_type_get_type" c_gtk_widget_help_type_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_unit_get_type" c_gtk_unit_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_tree_view_grid_lines_get_type" c_gtk_tree_view_grid_lines_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_tree_view_drop_position_get_type" c_gtk_tree_view_drop_position_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_tree_view_column_sizing_get_type" c_gtk_tree_view_column_sizing_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_toolbar_style_get_type" c_gtk_toolbar_style_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_toolbar_space_style_get_type" c_gtk_toolbar_space_style_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_text_window_type_get_type" c_gtk_text_window_type_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_text_view_layer_get_type" c_gtk_text_view_layer_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_text_extend_selection_get_type" c_gtk_text_extend_selection_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_text_direction_get_type" c_gtk_text_direction_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_text_buffer_target_info_get_type" c_gtk_text_buffer_target_info_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_state_type_get_type" c_gtk_state_type_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_stack_transition_type_get_type" c_gtk_stack_transition_type_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_spin_type_get_type" c_gtk_spin_type_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_spin_button_update_policy_get_type" c_gtk_spin_button_update_policy_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_sort_type_get_type" c_gtk_sort_type_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_size_request_mode_get_type" c_gtk_size_request_mode_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_size_group_mode_get_type" c_gtk_size_group_mode_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_shortcut_type_get_type" c_gtk_shortcut_type_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_shadow_type_get_type" c_gtk_shadow_type_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_sensitivity_type_get_type" c_gtk_sensitivity_type_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_selection_mode_get_type" c_gtk_selection_mode_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_scrollable_policy_get_type" c_gtk_scrollable_policy_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_scroll_type_get_type" c_gtk_scroll_type_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_scroll_step_get_type" c_gtk_scroll_step_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_revealer_transition_type_get_type" c_gtk_revealer_transition_type_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_response_type_get_type" c_gtk_response_type_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_resize_mode_get_type" c_gtk_resize_mode_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_relief_style_get_type" c_gtk_relief_style_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_recent_sort_type_get_type" c_gtk_recent_sort_type_get_type :: 
    IO GType

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

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

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

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

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

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

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

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

foreign import ccall "gtk_recent_manager_error_get_type" c_gtk_recent_manager_error_get_type :: 
    IO GType

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

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

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

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

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

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

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

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

foreign import ccall "gtk_recent_chooser_error_get_type" c_gtk_recent_chooser_error_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_rc_token_type_get_type" c_gtk_rc_token_type_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_propagation_phase_get_type" c_gtk_propagation_phase_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_print_status_get_type" c_gtk_print_status_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_print_quality_get_type" c_gtk_print_quality_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_print_pages_get_type" c_gtk_print_pages_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_print_operation_result_get_type" c_gtk_print_operation_result_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_print_operation_action_get_type" c_gtk_print_operation_action_get_type :: 
    IO GType

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

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

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

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

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

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

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

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

foreign import ccall "gtk_print_error_get_type" c_gtk_print_error_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_print_duplex_get_type" c_gtk_print_duplex_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_position_type_get_type" c_gtk_position_type_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_popover_constraint_get_type" c_gtk_popover_constraint_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_policy_type_get_type" c_gtk_policy_type_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_path_type_get_type" c_gtk_path_type_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_path_priority_type_get_type" c_gtk_path_priority_type_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_pan_direction_get_type" c_gtk_pan_direction_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_page_set_get_type" c_gtk_page_set_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_page_orientation_get_type" c_gtk_page_orientation_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_pad_action_type_get_type" c_gtk_pad_action_type_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_pack_type_get_type" c_gtk_pack_type_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_pack_direction_get_type" c_gtk_pack_direction_get_type :: 
    IO GType

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

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

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

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

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

foreign import ccall "gtk_orientation_get_type" c_gtk_orientation_get_type :: 
    IO GType

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

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

instance P.Enum NumberUpLayout where
    fromEnum :: NumberUpLayout -> Int
fromEnum NumberUpLayoutLrtb = 0
    fromEnum NumberUpLayoutLrbt = 1