-- | 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


-- ** AccessibleAutocomplete #enum:AccessibleAutocomplete#

    AccessibleAutocomplete(..)              ,


-- ** AccessibleInvalidState #enum:AccessibleInvalidState#

    AccessibleInvalidState(..)              ,


-- ** AccessibleProperty #enum:AccessibleProperty#

    AccessibleProperty(..)                  ,


-- ** AccessibleRelation #enum:AccessibleRelation#

    AccessibleRelation(..)                  ,


-- ** AccessibleRole #enum:AccessibleRole#

    AccessibleRole(..)                      ,


-- ** AccessibleSort #enum:AccessibleSort#

    AccessibleSort(..)                      ,


-- ** AccessibleState #enum:AccessibleState#

    AccessibleState(..)                     ,


-- ** AccessibleTristate #enum:AccessibleTristate#

    AccessibleTristate(..)                  ,


-- ** Align #enum:Align#

    Align(..)                               ,


-- ** ArrowType #enum:ArrowType#

    ArrowType(..)                           ,


-- ** AssistantPageType #enum:AssistantPageType#

    AssistantPageType(..)                   ,


-- ** BaselinePosition #enum:BaselinePosition#

    BaselinePosition(..)                    ,


-- ** BorderStyle #enum:BorderStyle#

    BorderStyle(..)                         ,


-- ** BuilderError #enum:BuilderError#

    BuilderError(..)                        ,
    catchBuilderError                       ,
    handleBuilderError                      ,


-- ** ButtonsType #enum:ButtonsType#

    ButtonsType(..)                         ,


-- ** CellRendererAccelMode #enum:CellRendererAccelMode#

    CellRendererAccelMode(..)               ,


-- ** CellRendererMode #enum:CellRendererMode#

    CellRendererMode(..)                    ,


-- ** ConstraintAttribute #enum:ConstraintAttribute#

    ConstraintAttribute(..)                 ,


-- ** ConstraintRelation #enum:ConstraintRelation#

    ConstraintRelation(..)                  ,


-- ** ConstraintStrength #enum:ConstraintStrength#

    ConstraintStrength(..)                  ,


-- ** ConstraintVflParserError #enum:ConstraintVflParserError#

    ConstraintVflParserError(..)            ,
    catchConstraintVflParserError           ,
    handleConstraintVflParserError          ,


-- ** CornerType #enum:CornerType#

    CornerType(..)                          ,


-- ** CssParserError #enum:CssParserError#

    CssParserError(..)                      ,
    catchCssParserError                     ,
    handleCssParserError                    ,


-- ** CssParserWarning #enum:CssParserWarning#

    CssParserWarning(..)                    ,


-- ** DeleteType #enum:DeleteType#

    DeleteType(..)                          ,


-- ** DirectionType #enum:DirectionType#

    DirectionType(..)                       ,


-- ** EditableProperties #enum:EditableProperties#

    EditableProperties(..)                  ,


-- ** EntryIconPosition #enum:EntryIconPosition#

    EntryIconPosition(..)                   ,


-- ** EventSequenceState #enum:EventSequenceState#

    EventSequenceState(..)                  ,


-- ** FileChooserAction #enum:FileChooserAction#

    FileChooserAction(..)                   ,


-- ** FileChooserError #enum:FileChooserError#

    FileChooserError(..)                    ,
    catchFileChooserError                   ,
    handleFileChooserError                  ,


-- ** FilterChange #enum:FilterChange#

    FilterChange(..)                        ,


-- ** FilterMatch #enum:FilterMatch#

    FilterMatch(..)                         ,


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


-- ** MessageType #enum:MessageType#

    MessageType(..)                         ,


-- ** MovementStep #enum:MovementStep#

    MovementStep(..)                        ,


-- ** NotebookTab #enum:NotebookTab#

    NotebookTab(..)                         ,


-- ** NumberUpLayout #enum:NumberUpLayout#

    NumberUpLayout(..)                      ,


-- ** Ordering #enum:Ordering#

    Ordering(..)                            ,


-- ** Orientation #enum:Orientation#

    Orientation(..)                         ,


-- ** Overflow #enum:Overflow#

    Overflow(..)                            ,


-- ** PackType #enum:PackType#

    PackType(..)                            ,


-- ** PadActionType #enum:PadActionType#

    PadActionType(..)                       ,


-- ** PageOrientation #enum:PageOrientation#

    PageOrientation(..)                     ,


-- ** PageSet #enum:PageSet#

    PageSet(..)                             ,


-- ** PanDirection #enum:PanDirection#

    PanDirection(..)                        ,


-- ** PolicyType #enum:PolicyType#

    PolicyType(..)                          ,


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


-- ** PropagationLimit #enum:PropagationLimit#

    PropagationLimit(..)                    ,


-- ** PropagationPhase #enum:PropagationPhase#

    PropagationPhase(..)                    ,


-- ** RecentManagerError #enum:RecentManagerError#

    RecentManagerError(..)                  ,
    catchRecentManagerError                 ,
    handleRecentManagerError                ,


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


-- ** ShortcutScope #enum:ShortcutScope#

    ShortcutScope(..)                       ,


-- ** ShortcutType #enum:ShortcutType#

    ShortcutType(..)                        ,


-- ** SizeGroupMode #enum:SizeGroupMode#

    SizeGroupMode(..)                       ,


-- ** SizeRequestMode #enum:SizeRequestMode#

    SizeRequestMode(..)                     ,


-- ** SortType #enum:SortType#

    SortType(..)                            ,


-- ** SorterChange #enum:SorterChange#

    SorterChange(..)                        ,


-- ** SorterOrder #enum:SorterOrder#

    SorterOrder(..)                         ,


-- ** SpinButtonUpdatePolicy #enum:SpinButtonUpdatePolicy#

    SpinButtonUpdatePolicy(..)              ,


-- ** SpinType #enum:SpinType#

    SpinType(..)                            ,


-- ** StackTransitionType #enum:StackTransitionType#

    StackTransitionType(..)                 ,


-- ** StringFilterMatchMode #enum:StringFilterMatchMode#

    StringFilterMatchMode(..)               ,


-- ** SystemSetting #enum:SystemSetting#

    SystemSetting(..)                       ,


-- ** TextDirection #enum:TextDirection#

    TextDirection(..)                       ,


-- ** TextExtendSelection #enum:TextExtendSelection#

    TextExtendSelection(..)                 ,


-- ** TextViewLayer #enum:TextViewLayer#

    TextViewLayer(..)                       ,


-- ** TextWindowType #enum:TextWindowType#

    TextWindowType(..)                      ,


-- ** TreeViewColumnSizing #enum:TreeViewColumnSizing#

    TreeViewColumnSizing(..)                ,


-- ** TreeViewDropPosition #enum:TreeViewDropPosition#

    TreeViewDropPosition(..)                ,


-- ** TreeViewGridLines #enum:TreeViewGridLines#

    TreeViewGridLines(..)                   ,


-- ** Unit #enum:Unit#

    Unit(..)                                ,


-- ** 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.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R


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

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

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

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

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

foreign import ccall "gtk_wrap_mode_get_type" c_gtk_wrap_mode_get_type :: 
    IO GType

instance B.Types.TypedObject WrapMode where
    glibType :: IO GType
glibType = IO GType
c_gtk_wrap_mode_get_type

instance B.Types.BoxedEnum WrapMode

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

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

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

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

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

foreign import ccall "gtk_unit_get_type" c_gtk_unit_get_type :: 
    IO GType

instance B.Types.TypedObject Unit where
    glibType :: IO GType
glibType = IO GType
c_gtk_unit_get_type

instance B.Types.BoxedEnum Unit

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

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

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

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

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

foreign import ccall "gtk_tree_view_grid_lines_get_type" c_gtk_tree_view_grid_lines_get_type :: 
    IO GType

instance B.Types.TypedObject TreeViewGridLines where
    glibType :: IO GType
glibType = IO GType
c_gtk_tree_view_grid_lines_get_type

instance B.Types.BoxedEnum TreeViewGridLines

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

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

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

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

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

foreign import ccall "gtk_tree_view_drop_position_get_type" c_gtk_tree_view_drop_position_get_type :: 
    IO GType

instance B.Types.TypedObject TreeViewDropPosition where
    glibType :: IO GType
glibType = IO GType
c_gtk_tree_view_drop_position_get_type

instance B.Types.BoxedEnum TreeViewDropPosition

-- Enum TreeViewColumnSizing
-- | The sizing method the column uses to determine its width.  Please note
-- that 'GI.Gtk.Enums.TreeViewColumnSizingAutosize' 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 every time the model changes.
    | TreeViewColumnSizingFixed
    -- ^ Columns are a fixed numbers of pixels wide.
    | AnotherTreeViewColumnSizing Int
    -- ^ Catch-all for unknown values
    deriving (Int -> TreeViewColumnSizing -> ShowS
[TreeViewColumnSizing] -> ShowS
TreeViewColumnSizing -> String
(Int -> TreeViewColumnSizing -> ShowS)
-> (TreeViewColumnSizing -> String)
-> ([TreeViewColumnSizing] -> ShowS)
-> Show TreeViewColumnSizing
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TreeViewColumnSizing] -> ShowS
$cshowList :: [TreeViewColumnSizing] -> ShowS
show :: TreeViewColumnSizing -> String
$cshow :: TreeViewColumnSizing -> String
showsPrec :: Int -> TreeViewColumnSizing -> ShowS
$cshowsPrec :: Int -> TreeViewColumnSizing -> ShowS
Show, TreeViewColumnSizing -> TreeViewColumnSizing -> Bool
(TreeViewColumnSizing -> TreeViewColumnSizing -> Bool)
-> (TreeViewColumnSizing -> TreeViewColumnSizing -> Bool)
-> Eq TreeViewColumnSizing
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TreeViewColumnSizing -> TreeViewColumnSizing -> Bool
$c/= :: TreeViewColumnSizing -> TreeViewColumnSizing -> Bool
== :: TreeViewColumnSizing -> TreeViewColumnSizing -> Bool
$c== :: TreeViewColumnSizing -> TreeViewColumnSizing -> Bool
Eq)

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

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

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

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

foreign import ccall "gtk_tree_view_column_sizing_get_type" c_gtk_tree_view_column_sizing_get_type :: 
    IO GType

instance B.Types.TypedObject TreeViewColumnSizing where
    glibType :: IO GType
glibType = IO GType
c_gtk_tree_view_column_sizing_get_type

instance B.Types.BoxedEnum TreeViewColumnSizing

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

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

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

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

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

foreign import ccall "gtk_text_window_type_get_type" c_gtk_text_window_type_get_type :: 
    IO GType

instance B.Types.TypedObject TextWindowType where
    glibType :: IO GType
glibType = IO GType
c_gtk_text_window_type_get_type

instance B.Types.BoxedEnum TextWindowType

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

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

    toEnum :: Int -> TextViewLayer
toEnum Int
0 = TextViewLayer
TextViewLayerBelowText
    toEnum Int
1 = TextViewLayer
TextViewLayerAboveText
    toEnum Int
k = Int -> TextViewLayer
AnotherTextViewLayer Int
k

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

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

foreign import ccall "gtk_text_view_layer_get_type" c_gtk_text_view_layer_get_type :: 
    IO GType

instance B.Types.TypedObject TextViewLayer where
    glibType :: IO GType
glibType = IO GType
c_gtk_text_view_layer_get_type

instance B.Types.BoxedEnum TextViewLayer

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

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

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

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

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

foreign import ccall "gtk_text_extend_selection_get_type" c_gtk_text_extend_selection_get_type :: 
    IO GType

instance B.Types.TypedObject TextExtendSelection where
    glibType :: IO GType
glibType = IO GType
c_gtk_text_extend_selection_get_type

instance B.Types.BoxedEnum TextExtendSelection

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

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

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

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

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

foreign import ccall "gtk_text_direction_get_type" c_gtk_text_direction_get_type :: 
    IO GType

instance B.Types.TypedObject TextDirection where
    glibType :: IO GType
glibType = IO GType
c_gtk_text_direction_get_type

instance B.Types.BoxedEnum TextDirection

-- Enum SystemSetting
-- | Values that can be passed to the GtkWidgetClass.system_setting_changed
-- vfunc to indicate that a system setting has changed and widgets may
-- need to drop caches, or react otherwise.
-- 
-- Most of the values correspond to t'GI.Gtk.Objects.Settings.Settings' properties.
-- 
-- More values may be added over time.
data SystemSetting = 
      SystemSettingDpi
    -- ^ the t'GI.Gtk.Objects.Settings.Settings':@/gtk-xft-dpi/@ setting has changed
    | SystemSettingFontName
    -- ^ The t'GI.Gtk.Objects.Settings.Settings':@/gtk-font-name/@ setting has changed
    | SystemSettingFontConfig
    -- ^ The font configuration has changed in a way that
    --     requires text to be redrawn. This can be any of the
    --     t'GI.Gtk.Objects.Settings.Settings':@/gtk-xft-antialias/@, t'GI.Gtk.Objects.Settings.Settings':@/gtk-xft-hinting/@,
    --     t'GI.Gtk.Objects.Settings.Settings':@/gtk-xft-hintstyle/@, t'GI.Gtk.Objects.Settings.Settings':@/gtk-xft-rgba/@ or
    --     t'GI.Gtk.Objects.Settings.Settings':@/gtk-fontconfig-timestamp/@ settings
    | SystemSettingDisplay
    -- ^ The display has changed
    | SystemSettingIconTheme
    -- ^ The icon theme has changed in a way that requires
    --     icons to be looked up again
    | AnotherSystemSetting Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SystemSetting -> ShowS
[SystemSetting] -> ShowS
SystemSetting -> String
(Int -> SystemSetting -> ShowS)
-> (SystemSetting -> String)
-> ([SystemSetting] -> ShowS)
-> Show SystemSetting
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SystemSetting] -> ShowS
$cshowList :: [SystemSetting] -> ShowS
show :: SystemSetting -> String
$cshow :: SystemSetting -> String
showsPrec :: Int -> SystemSetting -> ShowS
$cshowsPrec :: Int -> SystemSetting -> ShowS
Show, SystemSetting -> SystemSetting -> Bool
(SystemSetting -> SystemSetting -> Bool)
-> (SystemSetting -> SystemSetting -> Bool) -> Eq SystemSetting
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SystemSetting -> SystemSetting -> Bool
$c/= :: SystemSetting -> SystemSetting -> Bool
== :: SystemSetting -> SystemSetting -> Bool
$c== :: SystemSetting -> SystemSetting -> Bool
Eq)

instance P.Enum SystemSetting where
    fromEnum :: SystemSetting -> Int
fromEnum SystemSetting
SystemSettingDpi = Int
0
    fromEnum SystemSetting
SystemSettingFontName = Int
1
    fromEnum SystemSetting
SystemSettingFontConfig = Int
2
    fromEnum SystemSetting
SystemSettingDisplay = Int
3
    fromEnum SystemSetting
SystemSettingIconTheme = Int
4
    fromEnum (AnotherSystemSetting Int
k) = Int
k

    toEnum :: Int -> SystemSetting
toEnum Int
0 = SystemSetting
SystemSettingDpi
    toEnum Int
1 = SystemSetting
SystemSettingFontName
    toEnum Int
2 = SystemSetting
SystemSettingFontConfig
    toEnum Int
3 = SystemSetting
SystemSettingDisplay
    toEnum Int
4 = SystemSetting
SystemSettingIconTheme
    toEnum Int
k = Int -> SystemSetting
AnotherSystemSetting Int
k

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

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

foreign import ccall "gtk_system_setting_get_type" c_gtk_system_setting_get_type :: 
    IO GType

instance B.Types.TypedObject SystemSetting where
    glibType :: IO GType
glibType = IO GType
c_gtk_system_setting_get_type

instance B.Types.BoxedEnum SystemSetting

-- Enum StringFilterMatchMode
-- | Specifies how search strings are matched inside text.
data StringFilterMatchMode = 
      StringFilterMatchModeExact
    -- ^ The search string and
    --     text must match exactly.
    | StringFilterMatchModeSubstring
    -- ^ The search string
    --     must be contained as a substring inside the text.
    | StringFilterMatchModePrefix
    -- ^ The text must begin
    --     with the search string.
    | AnotherStringFilterMatchMode Int
    -- ^ Catch-all for unknown values
    deriving (Int -> StringFilterMatchMode -> ShowS
[StringFilterMatchMode] -> ShowS
StringFilterMatchMode -> String
(Int -> StringFilterMatchMode -> ShowS)
-> (StringFilterMatchMode -> String)
-> ([StringFilterMatchMode] -> ShowS)
-> Show StringFilterMatchMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StringFilterMatchMode] -> ShowS
$cshowList :: [StringFilterMatchMode] -> ShowS
show :: StringFilterMatchMode -> String
$cshow :: StringFilterMatchMode -> String
showsPrec :: Int -> StringFilterMatchMode -> ShowS
$cshowsPrec :: Int -> StringFilterMatchMode -> ShowS
Show, StringFilterMatchMode -> StringFilterMatchMode -> Bool
(StringFilterMatchMode -> StringFilterMatchMode -> Bool)
-> (StringFilterMatchMode -> StringFilterMatchMode -> Bool)
-> Eq StringFilterMatchMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StringFilterMatchMode -> StringFilterMatchMode -> Bool
$c/= :: StringFilterMatchMode -> StringFilterMatchMode -> Bool
== :: StringFilterMatchMode -> StringFilterMatchMode -> Bool
$c== :: StringFilterMatchMode -> StringFilterMatchMode -> Bool
Eq)

instance P.Enum StringFilterMatchMode where
    fromEnum :: StringFilterMatchMode -> Int
fromEnum StringFilterMatchMode
StringFilterMatchModeExact = Int
0
    fromEnum StringFilterMatchMode
StringFilterMatchModeSubstring = Int
1
    fromEnum StringFilterMatchMode
StringFilterMatchModePrefix = Int
2
    fromEnum (AnotherStringFilterMatchMode Int
k) = Int
k

    toEnum :: Int -> StringFilterMatchMode
toEnum Int
0 = StringFilterMatchMode
StringFilterMatchModeExact
    toEnum Int
1 = StringFilterMatchMode
StringFilterMatchModeSubstring
    toEnum Int
2 = StringFilterMatchMode
StringFilterMatchModePrefix
    toEnum Int
k = Int -> StringFilterMatchMode
AnotherStringFilterMatchMode Int
k

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

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

foreign import ccall "gtk_string_filter_match_mode_get_type" c_gtk_string_filter_match_mode_get_type :: 
    IO GType

instance B.Types.TypedObject StringFilterMatchMode where
    glibType :: IO GType
glibType = IO GType
c_gtk_string_filter_match_mode_get_type

instance B.Types.BoxedEnum StringFilterMatchMode

-- 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
    | StackTransitionTypeOverDown
    -- ^ Cover the old page by sliding down
    | StackTransitionTypeOverLeft
    -- ^ Cover the old page by sliding to the left
    | StackTransitionTypeOverRight
    -- ^ Cover the old page by sliding to the right
    | StackTransitionTypeUnderUp
    -- ^ Uncover the new page by sliding up
    | StackTransitionTypeUnderDown
    -- ^ Uncover the new page by sliding down
    | StackTransitionTypeUnderLeft
    -- ^ Uncover the new page by sliding to the left
    | StackTransitionTypeUnderRight
    -- ^ Uncover the new page by sliding to the right
    | StackTransitionTypeOverUpDown
    -- ^ Cover the old page sliding up or uncover the new page sliding down, according to order
    | StackTransitionTypeOverDownUp
    -- ^ Cover the old page sliding down or uncover the new page sliding up, according to order
    | StackTransitionTypeOverLeftRight
    -- ^ Cover the old page sliding left or uncover the new page sliding right, according to order
    | StackTransitionTypeOverRightLeft
    -- ^ Cover the old page sliding right or uncover the new page sliding left, according to order
    | StackTransitionTypeRotateLeft
    -- ^ Pretend the pages are sides of a cube and rotate that cube to the left
    | StackTransitionTypeRotateRight
    -- ^ Pretend the pages are sides of a cube and rotate that cube to the right
    | StackTransitionTypeRotateLeftRight
    -- ^ Pretend the pages are sides of a cube and rotate that cube to the left or right according to the children order
    | AnotherStackTransitionType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> StackTransitionType -> ShowS
[StackTransitionType] -> ShowS
StackTransitionType -> String
(Int -> StackTransitionType -> ShowS)
-> (StackTransitionType -> String)
-> ([StackTransitionType] -> ShowS)
-> Show StackTransitionType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StackTransitionType] -> ShowS
$cshowList :: [StackTransitionType] -> ShowS
show :: StackTransitionType -> String
$cshow :: StackTransitionType -> String
showsPrec :: Int -> StackTransitionType -> ShowS
$cshowsPrec :: Int -> StackTransitionType -> ShowS
Show, StackTransitionType -> StackTransitionType -> Bool
(StackTransitionType -> StackTransitionType -> Bool)
-> (StackTransitionType -> StackTransitionType -> Bool)
-> Eq StackTransitionType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StackTransitionType -> StackTransitionType -> Bool
$c/= :: StackTransitionType -> StackTransitionType -> Bool
== :: StackTransitionType -> StackTransitionType -> Bool
$c== :: StackTransitionType -> StackTransitionType -> Bool
Eq)

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

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

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

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

foreign import ccall "gtk_stack_transition_type_get_type" c_gtk_stack_transition_type_get_type :: 
    IO GType

instance B.Types.TypedObject StackTransitionType where
    glibType :: IO GType
glibType = IO GType
c_gtk_stack_transition_type_get_type

instance B.Types.BoxedEnum StackTransitionType

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

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

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

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

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

foreign import ccall "gtk_spin_type_get_type" c_gtk_spin_type_get_type :: 
    IO GType

instance B.Types.TypedObject SpinType where
    glibType :: IO GType
glibType = IO GType
c_gtk_spin_type_get_type

instance B.Types.BoxedEnum SpinType

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

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

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

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

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

foreign import ccall "gtk_spin_button_update_policy_get_type" c_gtk_spin_button_update_policy_get_type :: 
    IO GType

instance B.Types.TypedObject SpinButtonUpdatePolicy where
    glibType :: IO GType
glibType = IO GType
c_gtk_spin_button_update_policy_get_type

instance B.Types.BoxedEnum SpinButtonUpdatePolicy

-- Enum SorterOrder
-- | Describes the type of order that a t'GI.Gtk.Objects.Sorter.Sorter' may describe.
data SorterOrder = 
      SorterOrderPartial
    -- ^ A partial order. Any t'GI.Gtk.Enums.Ordering' is possible.
    | SorterOrderNone
    -- ^ No order, all elements are considered equal.
    --     'GI.Gtk.Objects.Sorter.sorterCompare' will only return 'GI.Gtk.Enums.OrderingEqual'.
    | SorterOrderTotal
    -- ^ A total order. 'GI.Gtk.Objects.Sorter.sorterCompare' will only
    --     return 'GI.Gtk.Enums.OrderingEqual' if an item is compared with itself. Two
    --     different items will never cause this value to be returned.
    | AnotherSorterOrder Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SorterOrder -> ShowS
[SorterOrder] -> ShowS
SorterOrder -> String
(Int -> SorterOrder -> ShowS)
-> (SorterOrder -> String)
-> ([SorterOrder] -> ShowS)
-> Show SorterOrder
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SorterOrder] -> ShowS
$cshowList :: [SorterOrder] -> ShowS
show :: SorterOrder -> String
$cshow :: SorterOrder -> String
showsPrec :: Int -> SorterOrder -> ShowS
$cshowsPrec :: Int -> SorterOrder -> ShowS
Show, SorterOrder -> SorterOrder -> Bool
(SorterOrder -> SorterOrder -> Bool)
-> (SorterOrder -> SorterOrder -> Bool) -> Eq SorterOrder
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SorterOrder -> SorterOrder -> Bool
$c/= :: SorterOrder -> SorterOrder -> Bool
== :: SorterOrder -> SorterOrder -> Bool
$c== :: SorterOrder -> SorterOrder -> Bool
Eq)

instance P.Enum SorterOrder where
    fromEnum :: SorterOrder -> Int
fromEnum SorterOrder
SorterOrderPartial = Int
0
    fromEnum SorterOrder
SorterOrderNone = Int
1
    fromEnum SorterOrder
SorterOrderTotal = Int
2
    fromEnum (AnotherSorterOrder Int
k) = Int
k

    toEnum :: Int -> SorterOrder
toEnum Int
0 = SorterOrder
SorterOrderPartial
    toEnum Int
1 = SorterOrder
SorterOrderNone
    toEnum Int
2 = SorterOrder
SorterOrderTotal
    toEnum Int
k = Int -> SorterOrder
AnotherSorterOrder Int
k

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

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

foreign import ccall "gtk_sorter_order_get_type" c_gtk_sorter_order_get_type :: 
    IO GType

instance B.Types.TypedObject SorterOrder where
    glibType :: IO GType
glibType = IO GType
c_gtk_sorter_order_get_type

instance B.Types.BoxedEnum SorterOrder

-- Enum SorterChange
-- | Describes changes in a sorter in more detail and allows users
-- to optimize resorting.
data SorterChange = 
      SorterChangeDifferent
    -- ^ The sorter change cannot be described
    --     by any of the other enumeration values
    | SorterChangeInverted
    -- ^ The sort order was inverted. Comparisons
    --     that returned 'GI.Gtk.Enums.OrderingSmaller' now return 'GI.Gtk.Enums.OrderingLarger'
    --     and vice versa. Other comparisons return the same values as before.
    | SorterChangeLessStrict
    -- ^ The sorter is less strict: Comparisons
    --     may now return 'GI.Gtk.Enums.OrderingEqual' that did not do so before.
    | SorterChangeMoreStrict
    -- ^ The sorter is more strict: Comparisons
    --     that did return 'GI.Gtk.Enums.OrderingEqual' may not do so anymore.
    | AnotherSorterChange Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SorterChange -> ShowS
[SorterChange] -> ShowS
SorterChange -> String
(Int -> SorterChange -> ShowS)
-> (SorterChange -> String)
-> ([SorterChange] -> ShowS)
-> Show SorterChange
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SorterChange] -> ShowS
$cshowList :: [SorterChange] -> ShowS
show :: SorterChange -> String
$cshow :: SorterChange -> String
showsPrec :: Int -> SorterChange -> ShowS
$cshowsPrec :: Int -> SorterChange -> ShowS
Show, SorterChange -> SorterChange -> Bool
(SorterChange -> SorterChange -> Bool)
-> (SorterChange -> SorterChange -> Bool) -> Eq SorterChange
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SorterChange -> SorterChange -> Bool
$c/= :: SorterChange -> SorterChange -> Bool
== :: SorterChange -> SorterChange -> Bool
$c== :: SorterChange -> SorterChange -> Bool
Eq)

instance P.Enum SorterChange where
    fromEnum :: SorterChange -> Int
fromEnum SorterChange
SorterChangeDifferent = Int
0
    fromEnum SorterChange
SorterChangeInverted = Int
1
    fromEnum SorterChange
SorterChangeLessStrict = Int
2
    fromEnum SorterChange
SorterChangeMoreStrict = Int
3
    fromEnum (AnotherSorterChange Int
k) = Int
k

    toEnum :: Int -> SorterChange
toEnum Int
0 = SorterChange
SorterChangeDifferent
    toEnum Int
1 = SorterChange
SorterChangeInverted
    toEnum Int
2 = SorterChange
SorterChangeLessStrict
    toEnum Int
3 = SorterChange
SorterChangeMoreStrict
    toEnum Int
k = Int -> SorterChange
AnotherSorterChange Int
k

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

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

foreign import ccall "gtk_sorter_change_get_type" c_gtk_sorter_change_get_type :: 
    IO GType

instance B.Types.TypedObject SorterChange where
    glibType :: IO GType
glibType = IO GType
c_gtk_sorter_change_get_type

instance B.Types.BoxedEnum SorterChange

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

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

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

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

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

foreign import ccall "gtk_sort_type_get_type" c_gtk_sort_type_get_type :: 
    IO GType

instance B.Types.TypedObject SortType where
    glibType :: IO GType
glibType = IO GType
c_gtk_sort_type_get_type

instance B.Types.BoxedEnum SortType

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

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

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

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

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

foreign import ccall "gtk_size_request_mode_get_type" c_gtk_size_request_mode_get_type :: 
    IO GType

instance B.Types.TypedObject SizeRequestMode where
    glibType :: IO GType
glibType = IO GType
c_gtk_size_request_mode_get_type

instance B.Types.BoxedEnum SizeRequestMode

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

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

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

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

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

foreign import ccall "gtk_size_group_mode_get_type" c_gtk_size_group_mode_get_type :: 
    IO GType

instance B.Types.TypedObject SizeGroupMode where
    glibType :: IO GType
glibType = IO GType
c_gtk_size_group_mode_get_type

instance B.Types.BoxedEnum SizeGroupMode

-- Enum ShortcutType
-- | GtkShortcutType specifies the kind of shortcut that is being described.
-- More values may be added to this enumeration over time.
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.
    | ShortcutTypeGestureSwipeLeft
    -- ^ The shortcut is a swipe gesture. GTK+ provides an icon and subtitle.
    | ShortcutTypeGestureSwipeRight
    -- ^ The shortcut is a swipe gesture. GTK+ provides an icon and subtitle.
    | AnotherShortcutType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ShortcutType -> ShowS
[ShortcutType] -> ShowS
ShortcutType -> String
(Int -> ShortcutType -> ShowS)
-> (ShortcutType -> String)
-> ([ShortcutType] -> ShowS)
-> Show ShortcutType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ShortcutType] -> ShowS
$cshowList :: [ShortcutType] -> ShowS
show :: ShortcutType -> String
$cshow :: ShortcutType -> String
showsPrec :: Int -> ShortcutType -> ShowS
$cshowsPrec :: Int -> ShortcutType -> ShowS
Show, ShortcutType -> ShortcutType -> Bool
(ShortcutType -> ShortcutType -> Bool)
-> (ShortcutType -> ShortcutType -> Bool) -> Eq ShortcutType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ShortcutType -> ShortcutType -> Bool
$c/= :: ShortcutType -> ShortcutType -> Bool
== :: ShortcutType -> ShortcutType -> Bool
$c== :: ShortcutType -> ShortcutType -> Bool
Eq)

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

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

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

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

foreign import ccall "gtk_shortcut_type_get_type" c_gtk_shortcut_type_get_type :: 
    IO GType

instance B.Types.TypedObject ShortcutType where
    glibType :: IO GType
glibType = IO GType
c_gtk_shortcut_type_get_type

instance B.Types.BoxedEnum ShortcutType

-- Enum ShortcutScope
-- | Describes where @/GtkShortcuts/@ added to a
-- t'GI.Gtk.Objects.ShortcutController.ShortcutController' get handled.
data ShortcutScope = 
      ShortcutScopeLocal
    -- ^ Shortcuts are handled inside
    --     the widget the controller belongs to.
    | ShortcutScopeManaged
    -- ^ Shortcuts are handled by
    --     the first ancestor that is a t'GI.Gtk.Interfaces.ShortcutManager.ShortcutManager'
    | ShortcutScopeGlobal
    -- ^ Shortcuts are handled by
    --     the root widget.
    | AnotherShortcutScope Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ShortcutScope -> ShowS
[ShortcutScope] -> ShowS
ShortcutScope -> String
(Int -> ShortcutScope -> ShowS)
-> (ShortcutScope -> String)
-> ([ShortcutScope] -> ShowS)
-> Show ShortcutScope
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ShortcutScope] -> ShowS
$cshowList :: [ShortcutScope] -> ShowS
show :: ShortcutScope -> String
$cshow :: ShortcutScope -> String
showsPrec :: Int -> ShortcutScope -> ShowS
$cshowsPrec :: Int -> ShortcutScope -> ShowS
Show, ShortcutScope -> ShortcutScope -> Bool
(ShortcutScope -> ShortcutScope -> Bool)
-> (ShortcutScope -> ShortcutScope -> Bool) -> Eq ShortcutScope
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ShortcutScope -> ShortcutScope -> Bool
$c/= :: ShortcutScope -> ShortcutScope -> Bool
== :: ShortcutScope -> ShortcutScope -> Bool
$c== :: ShortcutScope -> ShortcutScope -> Bool
Eq)

instance P.Enum ShortcutScope where
    fromEnum :: ShortcutScope -> Int
fromEnum ShortcutScope
ShortcutScopeLocal = Int
0
    fromEnum ShortcutScope
ShortcutScopeManaged = Int
1
    fromEnum ShortcutScope
ShortcutScopeGlobal = Int
2
    fromEnum (AnotherShortcutScope Int
k) = Int
k

    toEnum :: Int -> ShortcutScope
toEnum Int
0 = ShortcutScope
ShortcutScopeLocal
    toEnum Int
1 = ShortcutScope
ShortcutScopeManaged
    toEnum Int
2 = ShortcutScope
ShortcutScopeGlobal
    toEnum Int
k = Int -> ShortcutScope
AnotherShortcutScope Int
k

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

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

foreign import ccall "gtk_shortcut_scope_get_type" c_gtk_shortcut_scope_get_type :: 
    IO GType

instance B.Types.TypedObject ShortcutScope where
    glibType :: IO GType
glibType = IO GType
c_gtk_shortcut_scope_get_type

instance B.Types.BoxedEnum ShortcutScope

-- Enum SensitivityType
-- | Determines how GTK handles the sensitivity of various controls,
-- such as combo box buttons.
data SensitivityType = 
      SensitivityTypeAuto
    -- ^ The control is made insensitive if no
    --   action can be triggered
    | SensitivityTypeOn
    -- ^ The control is always sensitive
    | SensitivityTypeOff
    -- ^ The control is always insensitive
    | AnotherSensitivityType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SensitivityType -> ShowS
[SensitivityType] -> ShowS
SensitivityType -> String
(Int -> SensitivityType -> ShowS)
-> (SensitivityType -> String)
-> ([SensitivityType] -> ShowS)
-> Show SensitivityType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SensitivityType] -> ShowS
$cshowList :: [SensitivityType] -> ShowS
show :: SensitivityType -> String
$cshow :: SensitivityType -> String
showsPrec :: Int -> SensitivityType -> ShowS
$cshowsPrec :: Int -> SensitivityType -> ShowS
Show, SensitivityType -> SensitivityType -> Bool
(SensitivityType -> SensitivityType -> Bool)
-> (SensitivityType -> SensitivityType -> Bool)
-> Eq SensitivityType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SensitivityType -> SensitivityType -> Bool
$c/= :: SensitivityType -> SensitivityType -> Bool
== :: SensitivityType -> SensitivityType -> Bool
$c== :: SensitivityType -> SensitivityType -> Bool
Eq)

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

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

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

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

foreign import ccall "gtk_sensitivity_type_get_type" c_gtk_sensitivity_type_get_type :: 
    IO GType

instance B.Types.TypedObject SensitivityType where
    glibType :: IO GType
glibType = IO GType
c_gtk_sensitivity_type_get_type

instance B.Types.BoxedEnum SensitivityType

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

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

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

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

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

foreign import ccall "gtk_selection_mode_get_type" c_gtk_selection_mode_get_type :: 
    IO GType

instance B.Types.TypedObject SelectionMode where
    glibType :: IO GType
glibType = IO GType
c_gtk_selection_mode_get_type

instance B.Types.BoxedEnum SelectionMode

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

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

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

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

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

foreign import ccall "gtk_scrollable_policy_get_type" c_gtk_scrollable_policy_get_type :: 
    IO GType

instance B.Types.TypedObject ScrollablePolicy where
    glibType :: IO GType
glibType = IO GType
c_gtk_scrollable_policy_get_type

instance B.Types.BoxedEnum ScrollablePolicy

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

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

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

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

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

foreign import ccall "gtk_scroll_type_get_type" c_gtk_scroll_type_get_type :: 
    IO GType

instance B.Types.TypedObject ScrollType where
    glibType :: IO GType
glibType = IO GType
c_gtk_scroll_type_get_type

instance B.Types.BoxedEnum ScrollType

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

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

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

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

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

foreign import ccall "gtk_scroll_step_get_type" c_gtk_scroll_step_get_type :: 
    IO GType

instance B.Types.TypedObject ScrollStep where
    glibType :: IO GType
glibType = IO GType
c_gtk_scroll_step_get_type

instance B.Types.BoxedEnum ScrollStep

-- 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
    | RevealerTransitionTypeSwingRight
    -- ^ Floop in from the left
    | RevealerTransitionTypeSwingLeft
    -- ^ Floop in from the right
    | RevealerTransitionTypeSwingUp
    -- ^ Floop in from the bottom
    | RevealerTransitionTypeSwingDown
    -- ^ Floop in from the top
    | AnotherRevealerTransitionType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> RevealerTransitionType -> ShowS
[RevealerTransitionType] -> ShowS
RevealerTransitionType -> String
(Int -> RevealerTransitionType -> ShowS)
-> (RevealerTransitionType -> String)
-> ([RevealerTransitionType] -> ShowS)
-> Show RevealerTransitionType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RevealerTransitionType] -> ShowS
$cshowList :: [RevealerTransitionType] -> ShowS
show :: RevealerTransitionType -> String
$cshow :: RevealerTransitionType -> String
showsPrec :: Int -> RevealerTransitionType -> ShowS
$cshowsPrec :: Int -> RevealerTransitionType -> ShowS
Show, RevealerTransitionType -> RevealerTransitionType -> Bool
(RevealerTransitionType -> RevealerTransitionType -> Bool)
-> (RevealerTransitionType -> RevealerTransitionType -> Bool)
-> Eq RevealerTransitionType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RevealerTransitionType -> RevealerTransitionType -> Bool
$c/= :: RevealerTransitionType -> RevealerTransitionType -> Bool
== :: RevealerTransitionType -> RevealerTransitionType -> Bool
$c== :: RevealerTransitionType -> RevealerTransitionType -> Bool
Eq)

instance P.Enum RevealerTransitionType where
    fromEnum :: RevealerTransitionType -> Int
fromEnum RevealerTransitionType
RevealerTransitionTypeNone = Int
0
    fromEnum RevealerTransitionType
RevealerTransitionTypeCrossfade = Int
1
    fromEnum RevealerTransitionType
RevealerTransitionTypeSlideRight = Int
2
    fromEnum RevealerTransitionType
RevealerTransitionTypeSlideLeft = Int
3
    fromEnum RevealerTransitionType
RevealerTransitionTypeSlideUp = Int
4
    fromEnum RevealerTransitionType
RevealerTransitionTypeSlideDown = Int
5
    fromEnum RevealerTransitionType
RevealerTransitionTypeSwingRight = Int
6
    fromEnum RevealerTransitionType
RevealerTransitionTypeSwingLeft = Int
7
    fromEnum RevealerTransitionType
RevealerTransitionTypeSwingUp = Int
8
    fromEnum RevealerTransitionType
RevealerTransitionTypeSwingDown = Int
9
    fromEnum (AnotherRevealerTransitionType Int
k) = Int
k

    toEnum :: Int -> RevealerTransitionType
toEnum Int
0 = RevealerTransitionType
RevealerTransitionTypeNone
    toEnum Int
1 = RevealerTransitionType
RevealerTransitionTypeCrossfade
    toEnum Int
2 = RevealerTransitionType
RevealerTransitionTypeSlideRight
    toEnum Int
3 = RevealerTransitionType
RevealerTransitionTypeSlideLeft
    toEnum Int
4 = RevealerTransitionType
RevealerTransitionTypeSlideUp
    toEnum Int
5 = RevealerTransitionType
RevealerTransitionTypeSlideDown
    toEnum Int
6 = RevealerTransitionType
RevealerTransitionTypeSwingRight
    toEnum Int
7 = RevealerTransitionType
RevealerTransitionTypeSwingLeft
    toEnum Int
8 = RevealerTransitionType
RevealerTransitionTypeSwingUp
    toEnum Int
9 = RevealerTransitionType
RevealerTransitionTypeSwingDown
    toEnum Int
k = Int -> RevealerTransitionType
AnotherRevealerTransitionType Int
k

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

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

foreign import ccall "gtk_revealer_transition_type_get_type" c_gtk_revealer_transition_type_get_type :: 
    IO GType

instance B.Types.TypedObject RevealerTransitionType where
    glibType :: IO GType
glibType = IO GType
c_gtk_revealer_transition_type_get_type

instance B.Types.BoxedEnum RevealerTransitionType

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

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

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

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

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

foreign import ccall "gtk_response_type_get_type" c_gtk_response_type_get_type :: 
    IO GType

instance B.Types.TypedObject ResponseType where
    glibType :: IO GType
glibType = IO GType
c_gtk_response_type_get_type

instance B.Types.BoxedEnum ResponseType

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

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

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

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

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

-- | Catch exceptions of type `RecentManagerError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
catchRecentManagerError ::
    IO a ->
    (RecentManagerError -> GErrorMessage -> IO a) ->
    IO a
catchRecentManagerError :: forall a. 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 :: forall a. (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

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

foreign import ccall "gtk_recent_manager_error_get_type" c_gtk_recent_manager_error_get_type :: 
    IO GType

instance B.Types.TypedObject RecentManagerError where
    glibType :: IO GType
glibType = IO GType
c_gtk_recent_manager_error_get_type

instance B.Types.BoxedEnum RecentManagerError

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

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

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

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

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

foreign import ccall "gtk_propagation_phase_get_type" c_gtk_propagation_phase_get_type :: 
    IO GType

instance B.Types.TypedObject PropagationPhase where
    glibType :: IO GType
glibType = IO GType
c_gtk_propagation_phase_get_type

instance B.Types.BoxedEnum PropagationPhase

-- Enum PropagationLimit
-- | Describes limits of a t'GI.Gtk.Objects.EventController.EventController' for handling events
-- targeting other widgets.
data PropagationLimit = 
      PropagationLimitNone
    -- ^ Events are handled regardless of what their
    --   target is.
    | PropagationLimitSameNative
    -- ^ Events are only handled if their target
    --   is in the same t'GI.Gtk.Interfaces.Native.Native' as the event controllers widget. Note
    --   that some event types have two targets (origin and destination).
    | AnotherPropagationLimit Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PropagationLimit -> ShowS
[PropagationLimit] -> ShowS
PropagationLimit -> String
(Int -> PropagationLimit -> ShowS)
-> (PropagationLimit -> String)
-> ([PropagationLimit] -> ShowS)
-> Show PropagationLimit
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PropagationLimit] -> ShowS
$cshowList :: [PropagationLimit] -> ShowS
show :: PropagationLimit -> String
$cshow :: PropagationLimit -> String
showsPrec :: Int -> PropagationLimit -> ShowS
$cshowsPrec :: Int -> PropagationLimit -> ShowS
Show, PropagationLimit -> PropagationLimit -> Bool
(PropagationLimit -> PropagationLimit -> Bool)
-> (PropagationLimit -> PropagationLimit -> Bool)
-> Eq PropagationLimit
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PropagationLimit -> PropagationLimit -> Bool
$c/= :: PropagationLimit -> PropagationLimit -> Bool
== :: PropagationLimit -> PropagationLimit -> Bool
$c== :: PropagationLimit -> PropagationLimit -> Bool
Eq)

instance P.Enum PropagationLimit where
    fromEnum :: PropagationLimit -> Int
fromEnum PropagationLimit
PropagationLimitNone = Int
0
    fromEnum PropagationLimit
PropagationLimitSameNative = Int
1
    fromEnum (AnotherPropagationLimit Int
k) = Int
k

    toEnum :: Int -> PropagationLimit
toEnum Int
0 = PropagationLimit
PropagationLimitNone
    toEnum Int
1 = PropagationLimit
PropagationLimitSameNative
    toEnum Int
k = Int -> PropagationLimit
AnotherPropagationLimit Int
k

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

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

foreign import ccall "gtk_propagation_limit_get_type" c_gtk_propagation_limit_get_type :: 
    IO GType

instance B.Types.TypedObject PropagationLimit where
    glibType :: IO GType
glibType = IO GType
c_gtk_propagation_limit_get_type

instance B.Types.BoxedEnum PropagationLimit

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

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

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

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

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

foreign import ccall "gtk_print_status_get_type" c_gtk_print_status_get_type :: 
    IO GType

instance B.Types.TypedObject PrintStatus where
    glibType :: IO GType
glibType = IO GType
c_gtk_print_status_get_type

instance B.Types.BoxedEnum PrintStatus

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

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

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

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

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

foreign import ccall "gtk_print_quality_get_type" c_gtk_print_quality_get_type :: 
    IO GType

instance B.Types.TypedObject PrintQuality where
    glibType :: IO GType
glibType = IO GType
c_gtk_print_quality_get_type

instance B.Types.BoxedEnum PrintQuality

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

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

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

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

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

foreign import ccall "gtk_print_pages_get_type" c_gtk_print_pages_get_type :: 
    IO GType

instance B.Types.TypedObject PrintPages where
    glibType :: IO GType
glibType = IO GType
c_gtk_print_pages_get_type

instance B.Types.BoxedEnum PrintPages

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

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

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

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

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

foreign import ccall "gtk_print_operation_result_get_type" c_gtk_print_operation_result_get_type :: 
    IO GType

instance B.Types.TypedObject PrintOperationResult where
    glibType :: IO GType
glibType = IO GType
c_gtk_print_operation_result_get_type

instance B.Types.BoxedEnum PrintOperationResult

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

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

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

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

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

foreign import ccall "gtk_print_operation_action_get_type" c_gtk_print_operation_action_get_type :: 
    IO GType

instance B.Types.TypedObject PrintOperationAction where
    glibType :: IO GType
glibType = IO GType
c_gtk_print_operation_action_get_type

instance B.Types.BoxedEnum PrintOperationAction

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

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

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

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

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

-- | Catch exceptions of type `PrintError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
catchPrintError ::
    IO a ->
    (PrintError -> GErrorMessage -> IO a) ->
    IO a
catchPrintError :: forall a. 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 :: forall a. (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

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

foreign import ccall "gtk_print_error_get_type" c_gtk_print_error_get_type :: 
    IO GType

instance B.Types.TypedObject PrintError where
    glibType :: IO GType
glibType = IO GType
c_gtk_print_error_get_type

instance B.Types.BoxedEnum PrintError

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

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

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

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

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

foreign import ccall "gtk_print_duplex_get_type" c_gtk_print_duplex_get_type :: 
    IO GType

instance B.Types.TypedObject PrintDuplex where
    glibType :: IO GType
glibType = IO GType
c_gtk_print_duplex_get_type

instance B.Types.BoxedEnum PrintDuplex

-- 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', or the label of a t'GI.Gtk.Objects.Scale.Scale'.
data PositionType = 
      PositionTypeLeft
    -- ^ The feature is at the left edge.
    | PositionTypeRight
    -- ^ The feature is at the right edge.
    | PositionTypeTop
    -- ^ The feature is at the top edge.
    | PositionTypeBottom
    -- ^ The feature is at the bottom edge.
    | AnotherPositionType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PositionType -> ShowS
[PositionType] -> ShowS
PositionType -> String
(Int -> PositionType -> ShowS)
-> (PositionType -> String)
-> ([PositionType] -> ShowS)
-> Show PositionType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PositionType] -> ShowS
$cshowList :: [PositionType] -> ShowS
show :: PositionType -> String
$cshow :: PositionType -> String
showsPrec :: Int -> PositionType -> ShowS
$cshowsPrec :: Int -> PositionType -> ShowS
Show, PositionType -> PositionType -> Bool
(PositionType -> PositionType -> Bool)
-> (PositionType -> PositionType -> Bool) -> Eq PositionType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PositionType -> PositionType -> Bool
$c/= :: PositionType -> PositionType -> Bool
== :: PositionType -> PositionType -> Bool
$c== :: PositionType -> PositionType -> Bool
Eq)

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

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

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

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

foreign import ccall "gtk_position_type_get_type" c_gtk_position_type_get_type :: 
    IO GType

instance B.Types.TypedObject PositionType where
    glibType :: IO GType
glibType = IO GType
c_gtk_position_type_get_type

instance B.Types.BoxedEnum PositionType

-- 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.
    | AnotherPolicyType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PolicyType -> ShowS
[PolicyType] -> ShowS
PolicyType -> String
(Int -> PolicyType -> ShowS)
-> (PolicyType -> String)
-> ([PolicyType] -> ShowS)
-> Show PolicyType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PolicyType] -> ShowS
$cshowList :: [PolicyType] -> ShowS
show :: PolicyType -> String
$cshow :: PolicyType -> String
showsPrec :: Int -> PolicyType -> ShowS
$cshowsPrec :: Int -> PolicyType -> ShowS
Show, PolicyType -> PolicyType -> Bool
(PolicyType -> PolicyType -> Bool)
-> (PolicyType -> PolicyType -> Bool) -> Eq PolicyType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PolicyType -> PolicyType -> Bool
$c/= :: PolicyType -> PolicyType -> Bool
== :: PolicyType -> PolicyType -> Bool
$c== :: PolicyType -> PolicyType -> Bool
Eq)

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

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

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

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

foreign import ccall "gtk_policy_type_get_type" c_gtk_policy_type_get_type :: 
    IO GType

instance B.Types.TypedObject PolicyType where
    glibType :: IO GType
glibType = IO GType
c_gtk_policy_type_get_type

instance B.Types.BoxedEnum PolicyType

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

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

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

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

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

foreign import ccall "gtk_pan_direction_get_type" c_gtk_pan_direction_get_type :: 
    IO GType

instance B.Types.TypedObject PanDirection where
    glibType :: IO GType
glibType = IO GType
c_gtk_pan_direction_get_type

instance B.Types.BoxedEnum PanDirection

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

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

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

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

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

foreign import ccall "gtk_page_set_get_type" c_gtk_page_set_get_type :: 
    IO GType

instance B.Types.TypedObject PageSet where
    glibType :: IO GType
glibType = IO GType
c_gtk_page_set_get_type

instance B.Types.BoxedEnum PageSet

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

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

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

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

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

foreign import ccall "gtk_page_orientation_get_type" c_gtk_page_orientation_get_type :: 
    IO GType

instance B.Types.TypedObject PageOrientation where
    glibType :: IO GType
glibType = IO GType
c_gtk_page_orientation_get_type

instance B.Types.BoxedEnum PageOrientation

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

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

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

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

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

foreign import ccall "gtk_pad_action_type_get_type" c_gtk_pad_action_type_get_type :: 
    IO GType

instance B.Types.TypedObject PadActionType where
    glibType :: IO GType
glibType = IO GType
c_gtk_pad_action_type_get_type

instance B.Types.BoxedEnum PadActionType

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

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

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

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

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

foreign import ccall "gtk_pack_type_get_type" c_gtk_pack_type_get_type :: 
    IO GType

instance B.Types.TypedObject PackType where
    glibType :: IO GType
glibType = IO GType
c_gtk_pack_type_get_type

instance B.Types.BoxedEnum PackType

-- Enum Overflow
-- | Defines how content overflowing a given area should be handled, such as
-- with 'GI.Gtk.Objects.Widget.widgetSetOverflow'. This property is modeled after the CSS overflow
-- property, but implements it only partially.
data Overflow = 
      OverflowVisible
    -- ^ No change is applied. Content is drawn at the specified
    --     position.
    | OverflowHidden
    -- ^ Content is clipped to the bounds of the area. Content
    --     outside the area is not drawn and cannot be interacted with.
    | AnotherOverflow Int
    -- ^ Catch-all for unknown values
    deriving (Int -> Overflow -> ShowS
[Overflow] -> ShowS
Overflow -> String
(Int -> Overflow -> ShowS)
-> (Overflow -> String) -> ([Overflow] -> ShowS) -> Show Overflow
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Overflow] -> ShowS
$cshowList :: [Overflow] -> ShowS
show :: Overflow -> String
$cshow :: Overflow -> String
showsPrec :: Int -> Overflow -> ShowS
$cshowsPrec :: Int -> Overflow -> ShowS
Show, Overflow -> Overflow -> Bool
(Overflow -> Overflow -> Bool)
-> (Overflow -> Overflow -> Bool) -> Eq Overflow
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Overflow -> Overflow -> Bool
$c/= :: Overflow -> Overflow -> Bool
== :: Overflow -> Overflow -> Bool
$c== :: Overflow -> Overflow -> Bool
Eq)

instance P.Enum Overflow where
    fromEnum :: Overflow -> Int
fromEnum Overflow
OverflowVisible = Int
0
    fromEnum Overflow
OverflowHidden = Int
1
    fromEnum (AnotherOverflow Int
k) = Int
k

    toEnum :: Int -> Overflow
toEnum Int
0 = Overflow
OverflowVisible
    toEnum Int
1 = Overflow
OverflowHidden
    toEnum Int
k = Int -> Overflow
AnotherOverflow Int
k

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

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

foreign import ccall "gtk_overflow_get_type" c_gtk_overflow_get_type :: 
    IO GType

instance B.Types.TypedObject Overflow where
    glibType :: IO GType
glibType = IO GType
c_gtk_overflow_get_type

instance B.Types.BoxedEnum Overflow

-- 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.Box.Box' or
-- t'GI.Gtk.Objects.GesturePan.GesturePan'.
data Orientation = 
      OrientationHorizontal
    -- ^ The element is in horizontal orientation.
    | OrientationVertical
    -- ^ The element is in vertical orientation.
    | AnotherOrientation Int
    -- ^ Catch-all for unknown values
    deriving (Int -> Orientation -> ShowS
[Orientation] -> ShowS
Orientation -> String
(Int -> Orientation -> ShowS)
-> (Orientation -> String)
-> ([Orientation] -> ShowS)
-> Show Orientation
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Orientation] -> ShowS
$cshowList :: [Orientation] -> ShowS
show :: Orientation -> String
$cshow :: Orientation -> String
showsPrec :: Int -> Orientation -> ShowS
$cshowsPrec :: Int -> Orientation -> ShowS
Show, Orientation -> Orientation -> Bool
(Orientation -> Orientation -> Bool)
-> (Orientation -> Orientation -> Bool) -> Eq Orientation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Orientation -> Orientation -> Bool
$c/= :: Orientation -> Orientation -> Bool
== :: Orientation -> Orientation -> Bool
$c== :: Orientation -> Orientation -> Bool
Eq)

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

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

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

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

foreign import ccall "gtk_orientation_get_type" c_gtk_orientation_get_type :: 
    IO GType

instance B.Types.TypedObject Orientation where
    glibType :: IO GType
glibType = IO GType
c_gtk_orientation_get_type

instance B.Types.BoxedEnum Orientation

-- Enum Ordering
-- | Describes the way two values can be compared.
-- 
-- These values can be used with a t'GI.GLib.Callbacks.CompareFunc'. However, a
-- t'GI.GLib.Callbacks.CompareFunc' is allowed to return any integer values.
-- For converting such a value to a t'GI.Gtk.Enums.Ordering', use
-- @/gtk_ordering_from_cmpfunc()/@.
data Ordering = 
      OrderingSmaller
    -- ^ the first value is smaller than the second
    | OrderingEqual
    -- ^ the two values are equal
    | OrderingLarger
    -- ^ the first value is larger than the second
    | AnotherOrdering Int
    -- ^ Catch-all for unknown values
    deriving (Int -> Ordering -> ShowS
[Ordering] -> ShowS
Ordering -> String
(Int -> Ordering -> ShowS)
-> (Ordering -> String) -> ([Ordering] -> ShowS) -> Show Ordering
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Ordering] -> ShowS
$cshowList :: [Ordering] -> ShowS
show :: Ordering -> String
$cshow :: Ordering -> String
showsPrec :: Int -> Ordering -> ShowS
$cshowsPrec :: Int -> Ordering -> ShowS
Show, Ordering -> Ordering -> Bool
(Ordering -> Ordering -> Bool)
-> (Ordering -> Ordering -> Bool) -> Eq Ordering
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Ordering -> Ordering -> Bool
$c/= :: Ordering -> Ordering -> Bool
== :: Ordering -> Ordering -> Bool
$c== :: Ordering -> Ordering -> Bool
Eq)

instance P.Enum Ordering where
    fromEnum :: Ordering -> Int
fromEnum Ordering
OrderingSmaller = Int
-1
    fromEnum Ordering
OrderingEqual = Int
0
    fromEnum Ordering
OrderingLarger = Int
1
    fromEnum (AnotherOrdering Int
k) = Int
k

    toEnum :: Int -> Ordering
toEnum Int
-1 = Ordering
OrderingSmaller
    toEnum Int
0 = Ordering
OrderingEqual
    toEnum Int
1 = Ordering
OrderingLarger
    toEnum Int
k = Int -> Ordering
AnotherOrdering Int
k

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

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

foreign import ccall "gtk_ordering_get_type" c_gtk_ordering_get_type :: 
    IO GType

instance B.Types.TypedObject Ordering where
    glibType :: IO GType
glibType = IO GType
c_gtk_ordering_get_type

instance B.Types.BoxedEnum Ordering

-- 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/gtk4/stable/layout-lrtb.png>>
    | NumberUpLayoutLrbt
    -- ^ <<https://developer.gnome.org/gtk4/stable/layout-lrbt.png>>
    | NumberUpLayoutRltb
    -- ^ <<https://developer.gnome.org/gtk4/stable/layout-rltb.png>>
    | NumberUpLayoutRlbt
    -- ^ <<https://developer.gnome.org/gtk4/stable/layout-rlbt.png>>
    | NumberUpLayoutTblr
    -- ^ <<https://developer.gnome.org/gtk4/stable/layout-tblr.png>>
    | NumberUpLayoutTbrl
    -- ^ <<https://developer.gnome.org/gtk4/stable/layout-tbrl.png>>
    | NumberUpLayoutBtlr
    -- ^ <<https://developer.gnome.org/gtk4/stable/layout-btlr.png>>
    | NumberUpLayoutBtrl
    -- ^ <<https://developer.gnome.org/gtk4/stable/layout-btrl.png>>
    | AnotherNumberUpLayout Int
    -- ^ Catch-all for unknown values
    deriving (Int -> NumberUpLayout -> ShowS
[NumberUpLayout] -> ShowS
NumberUpLayout -> String
(Int -> NumberUpLayout -> ShowS)
-> (NumberUpLayout -> String)
-> ([NumberUpLayout] -> ShowS)
-> Show NumberUpLayout
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NumberUpLayout] -> ShowS
$cshowList :: [NumberUpLayout] -> ShowS
show :: NumberUpLayout -> String
$cshow :: NumberUpLayout -> String
showsPrec :: Int -> NumberUpLayout -> ShowS
$cshowsPrec :: Int -> NumberUpLayout -> ShowS
Show, NumberUpLayout -> NumberUpLayout -> Bool
(NumberUpLayout -> NumberUpLayout -> Bool)
-> (NumberUpLayout -> NumberUpLayout -> Bool) -> Eq NumberUpLayout
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NumberUpLayout -> NumberUpLayout -> Bool
$c/= :: NumberUpLayout -> NumberUpLayout -> Bool
== :: NumberUpLayout -> NumberUpLayout -> Bool
$c== :: NumberUpLayout -> NumberUpLayout -> Bool
Eq)

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

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

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

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

foreign import ccall "gtk_number_up_layout_get_type" c_gtk_number_up_layout_get_type :: 
    IO GType

instance B.Types.TypedObject NumberUpLayout where
    glibType :: IO GType
glibType = IO GType
c_gtk_number_up_layout_get_type

instance B.Types.BoxedEnum NumberUpLayout

-- Enum NotebookTab
-- | The parameter used in the action signals of t'GI.Gtk.Objects.Notebook.Notebook'.
data NotebookTab = 
      NotebookTabFirst
    -- ^ the first tab in the notebook
    | NotebookTabLast
    -- ^ the last tab in the notebook
    | AnotherNotebookTab Int
    -- ^ Catch-all for unknown values
    deriving (Int -> NotebookTab -> ShowS
[NotebookTab] -> ShowS
NotebookTab -> String
(Int -> NotebookTab -> ShowS)
-> (NotebookTab -> String)
-> ([NotebookTab] -> ShowS)
-> Show NotebookTab
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NotebookTab] -> ShowS
$cshowList :: [NotebookTab] -> ShowS
show :: NotebookTab -> String
$cshow :: NotebookTab -> String
showsPrec :: Int -> NotebookTab -> ShowS
$cshowsPrec :: Int -> NotebookTab -> ShowS
Show, NotebookTab -> NotebookTab -> Bool
(NotebookTab -> NotebookTab -> Bool)
-> (NotebookTab -> NotebookTab -> Bool) -> Eq NotebookTab
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NotebookTab -> NotebookTab -> Bool
$c/= :: NotebookTab -> NotebookTab -> Bool
== :: NotebookTab -> NotebookTab -> Bool
$c== :: NotebookTab -> NotebookTab -> Bool
Eq)

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

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

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

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

foreign import ccall "gtk_notebook_tab_get_type" c_gtk_notebook_tab_get_type :: 
    IO GType

instance B.Types.TypedObject NotebookTab where
    glibType :: IO GType
glibType = IO GType
c_gtk_notebook_tab_get_type

instance B.Types.BoxedEnum NotebookTab

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

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

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

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

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

foreign import ccall "gtk_movement_step_get_type" c_gtk_movement_step_get_type :: 
    IO GType

instance B.Types.TypedObject MovementStep where
    glibType :: IO GType
glibType = IO GType
c_gtk_movement_step_get_type

instance B.Types.BoxedEnum MovementStep

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

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

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

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

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

foreign import ccall "gtk_message_type_get_type" c_gtk_message_type_get_type :: 
    IO GType

instance B.Types.TypedObject MessageType where
    glibType :: IO GType
glibType = IO GType
c_gtk_message_type_get_type

instance B.Types.BoxedEnum MessageType

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

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

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

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

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

foreign import ccall "gtk_license_get_type" c_gtk_license_get_type :: 
    IO GType

instance B.Types.TypedObject License where
    glibType :: IO GType
glibType = IO GType
c_gtk_license_get_type

instance B.Types.BoxedEnum License

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

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

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

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

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

foreign import ccall "gtk_level_bar_mode_get_type" c_gtk_level_bar_mode_get_type :: 
    IO GType

instance B.Types.TypedObject LevelBarMode where
    glibType :: IO GType
glibType = IO GType
c_gtk_level_bar_mode_get_type

instance B.Types.BoxedEnum LevelBarMode

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

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

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

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

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

foreign import ccall "gtk_justification_get_type" c_gtk_justification_get_type :: 
    IO GType

instance B.Types.TypedObject Justification where
    glibType :: IO GType
glibType = IO GType
c_gtk_justification_get_type

instance B.Types.BoxedEnum Justification

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

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

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

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

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

foreign import ccall "gtk_input_purpose_get_type" c_gtk_input_purpose_get_type :: 
    IO GType

instance B.Types.TypedObject InputPurpose where
    glibType :: IO GType
glibType = IO GType
c_gtk_input_purpose_get_type

instance B.Types.BoxedEnum InputPurpose

-- Enum ImageType
-- | Describes the image data representation used by a t'GI.Gtk.Objects.Image.Image'. If you
-- want to get the image from the widget, you can only get the
-- currently-stored representation. e.g.  if the
-- 'GI.Gtk.Objects.Image.imageGetStorageType' returns @/GTK_IMAGE_PAINTABLE/@, then you can
-- call 'GI.Gtk.Objects.Image.imageGetPaintable'.  For empty images, you can request any
-- storage type (call any of the \"get\" functions), but they will all
-- return 'P.Nothing' values.
data ImageType = 
      ImageTypeEmpty
    -- ^ there is no image displayed by the widget
    | ImageTypeIconName
    -- ^ the widget contains a named icon
    | ImageTypeGicon
    -- ^ the widget contains a t'GI.Gio.Interfaces.Icon.Icon'
    | ImageTypePaintable
    -- ^ the widget contains a t'GI.Gdk.Interfaces.Paintable.Paintable'
    | AnotherImageType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ImageType -> ShowS
[ImageType] -> ShowS
ImageType -> String
(Int -> ImageType -> ShowS)
-> (ImageType -> String)
-> ([ImageType] -> ShowS)
-> Show ImageType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ImageType] -> ShowS
$cshowList :: [ImageType] -> ShowS
show :: ImageType -> String
$cshow :: ImageType -> String
showsPrec :: Int -> ImageType -> ShowS
$cshowsPrec :: Int -> ImageType -> ShowS
Show, ImageType -> ImageType -> Bool
(ImageType -> ImageType -> Bool)
-> (ImageType -> ImageType -> Bool) -> Eq ImageType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ImageType -> ImageType -> Bool
$c/= :: ImageType -> ImageType -> Bool
== :: ImageType -> ImageType -> Bool
$c== :: ImageType -> ImageType -> Bool
Eq)

instance P.Enum ImageType where
    fromEnum :: ImageType -> Int
fromEnum ImageType
ImageTypeEmpty = Int
0
    fromEnum ImageType
ImageTypeIconName = Int
1
    fromEnum ImageType
ImageTypeGicon = Int
2
    fromEnum ImageType
ImageTypePaintable = Int
3
    fromEnum (AnotherImageType Int
k) = Int
k

    toEnum :: Int -> ImageType
toEnum Int
0 = ImageType
ImageTypeEmpty
    toEnum Int
1 = ImageType
ImageTypeIconName
    toEnum Int
2 = ImageType
ImageTypeGicon
    toEnum Int
3 = ImageType
ImageTypePaintable
    toEnum Int
k = Int -> ImageType
AnotherImageType Int
k

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

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

foreign import ccall "gtk_image_type_get_type" c_gtk_image_type_get_type :: 
    IO GType

instance B.Types.TypedObject ImageType where
    glibType :: IO GType
glibType = IO GType
c_gtk_image_type_get_type

instance B.Types.BoxedEnum ImageType

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

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

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

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

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

foreign import ccall "gtk_icon_view_drop_position_get_type" c_gtk_icon_view_drop_position_get_type :: 
    IO GType

instance B.Types.TypedObject IconViewDropPosition where
    glibType :: IO GType
glibType = IO GType
c_gtk_icon_view_drop_position_get_type

instance B.Types.BoxedEnum IconViewDropPosition

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

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

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

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

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

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

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

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

foreign import ccall "gtk_icon_theme_error_get_type" c_gtk_icon_theme_error_get_type :: 
    IO GType

instance B.Types.TypedObject IconThemeError where
    glibType :: IO GType
glibType = IO GType
c_gtk_icon_theme_error_get_type

instance B.Types.BoxedEnum IconThemeError

-- Enum IconSize
-- | Built-in icon sizes.
-- 
-- Icon sizes default to being inherited. Where they cannot be
-- inherited, text size is the default.
-- 
-- All widgets which use GtkIconSize set the normal-icons or large-icons
-- style classes correspondingly, and let themes determine the actual size
-- to be used with the -gtk-icon-size CSS property.
data IconSize = 
      IconSizeInherit
    -- ^ Keep the size of the parent element
    | IconSizeNormal
    -- ^ Size similar to text size
    | IconSizeLarge
    -- ^ Large size, for example in an icon view
    | AnotherIconSize Int
    -- ^ Catch-all for unknown values
    deriving (Int -> IconSize -> ShowS
[IconSize] -> ShowS
IconSize -> String
(Int -> IconSize -> ShowS)
-> (IconSize -> String) -> ([IconSize] -> ShowS) -> Show IconSize
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [IconSize] -> ShowS
$cshowList :: [IconSize] -> ShowS
show :: IconSize -> String
$cshow :: IconSize -> String
showsPrec :: Int -> IconSize -> ShowS
$cshowsPrec :: Int -> IconSize -> ShowS
Show, IconSize -> IconSize -> Bool
(IconSize -> IconSize -> Bool)
-> (IconSize -> IconSize -> Bool) -> Eq IconSize
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: IconSize -> IconSize -> Bool
$c/= :: IconSize -> IconSize -> Bool
== :: IconSize -> IconSize -> Bool
$c== :: IconSize -> IconSize -> Bool
Eq)

instance P.Enum IconSize where
    fromEnum :: IconSize -> Int
fromEnum IconSize
IconSizeInherit = Int
0
    fromEnum IconSize
IconSizeNormal = Int
1
    fromEnum IconSize
IconSizeLarge = Int
2
    fromEnum (AnotherIconSize Int
k) = Int
k

    toEnum :: Int -> IconSize
toEnum Int
0 = IconSize
IconSizeInherit
    toEnum Int
1 = IconSize
IconSizeNormal
    toEnum Int
2 = IconSize
IconSizeLarge
    toEnum Int
k = Int -> IconSize
AnotherIconSize Int
k

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

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

foreign import ccall "gtk_icon_size_get_type" c_gtk_icon_size_get_type :: 
    IO GType

instance B.Types.TypedObject IconSize where
    glibType :: IO GType
glibType = IO GType
c_gtk_icon_size_get_type

instance B.Types.BoxedEnum IconSize

-- Enum FilterMatch
-- | Describes the known strictness of a filter.
-- 
-- Note that for filters where the strictness is not known,
-- 'GI.Gtk.Enums.FilterMatchSome' is always an acceptable value,
-- even if a filter does match all or no items.
data FilterMatch = 
      FilterMatchSome
    -- ^ The filter matches some items,
    --     'GI.Gtk.Objects.Filter.filterMatch' may return 'P.True' or 'P.False'
    | FilterMatchNone
    -- ^ The filter does not match any item,
    --     'GI.Gtk.Objects.Filter.filterMatch' will always return 'P.False'.
    | FilterMatchAll
    -- ^ The filter matches all items,
    --     'GI.Gtk.Objects.Filter.filterMatch' will alays return 'P.True'.
    | AnotherFilterMatch Int
    -- ^ Catch-all for unknown values
    deriving (Int -> FilterMatch -> ShowS
[FilterMatch] -> ShowS
FilterMatch -> String
(Int -> FilterMatch -> ShowS)
-> (FilterMatch -> String)
-> ([FilterMatch] -> ShowS)
-> Show FilterMatch
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FilterMatch] -> ShowS
$cshowList :: [FilterMatch] -> ShowS
show :: FilterMatch -> String
$cshow :: FilterMatch -> String
showsPrec :: Int -> FilterMatch -> ShowS
$cshowsPrec :: Int -> FilterMatch -> ShowS
Show, FilterMatch -> FilterMatch -> Bool
(FilterMatch -> FilterMatch -> Bool)
-> (FilterMatch -> FilterMatch -> Bool) -> Eq FilterMatch
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FilterMatch -> FilterMatch -> Bool
$c/= :: FilterMatch -> FilterMatch -> Bool
== :: FilterMatch -> FilterMatch -> Bool
$c== :: FilterMatch -> FilterMatch -> Bool
Eq)

instance P.Enum FilterMatch where
    fromEnum :: FilterMatch -> Int
fromEnum FilterMatch
FilterMatchSome = Int
0
    fromEnum FilterMatch
FilterMatchNone = Int
1
    fromEnum FilterMatch
FilterMatchAll = Int
2
    fromEnum (AnotherFilterMatch Int
k) = Int
k

    toEnum :: Int -> FilterMatch
toEnum Int
0 = FilterMatch
FilterMatchSome
    toEnum Int
1 = FilterMatch
FilterMatchNone
    toEnum Int
2 = FilterMatch
FilterMatchAll
    toEnum Int
k = Int -> FilterMatch
AnotherFilterMatch Int
k

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

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

foreign import ccall "gtk_filter_match_get_type" c_gtk_filter_match_get_type :: 
    IO GType

instance B.Types.TypedObject FilterMatch where
    glibType :: IO GType
glibType = IO GType
c_gtk_filter_match_get_type

instance B.Types.BoxedEnum FilterMatch

-- Enum FilterChange
-- | Describes changes in a filter in more detail and allows objects
-- using the filter to optimize refiltering items.
-- 
-- If you are writing an implementation and are not sure which
-- value to pass, 'GI.Gtk.Enums.FilterChangeDifferent' is always a correct
-- choice.
data FilterChange = 
      FilterChangeDifferent
    -- ^ The filter change cannot be
    --     described with any of the other enumeration values.
    | FilterChangeLessStrict
    -- ^ The filter is less strict than
    --     it was before: All items that it used to return 'P.True' for
    --     still return 'P.True', others now may, too.
    | FilterChangeMoreStrict
    -- ^ The filter is more strict than
    --     it was before: All items that it used to return 'P.False' for
    --     still return 'P.False', others now may, too.
    | AnotherFilterChange Int
    -- ^ Catch-all for unknown values
    deriving (Int -> FilterChange -> ShowS
[FilterChange] -> ShowS
FilterChange -> String
(Int -> FilterChange -> ShowS)
-> (FilterChange -> String)
-> ([FilterChange] -> ShowS)
-> Show FilterChange
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FilterChange] -> ShowS
$cshowList :: [FilterChange] -> ShowS
show :: FilterChange -> String
$cshow :: FilterChange -> String
showsPrec :: Int -> FilterChange -> ShowS
$cshowsPrec :: Int -> FilterChange -> ShowS
Show, FilterChange -> FilterChange -> Bool
(FilterChange -> FilterChange -> Bool)
-> (FilterChange -> FilterChange -> Bool) -> Eq FilterChange
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FilterChange -> FilterChange -> Bool
$c/= :: FilterChange -> FilterChange -> Bool
== :: FilterChange -> FilterChange -> Bool
$c== :: FilterChange -> FilterChange -> Bool
Eq)

instance P.Enum FilterChange where
    fromEnum :: FilterChange -> Int
fromEnum FilterChange
FilterChangeDifferent = Int
0
    fromEnum FilterChange
FilterChangeLessStrict = Int
1
    fromEnum FilterChange
FilterChangeMoreStrict = Int
2
    fromEnum (AnotherFilterChange Int
k) = Int
k

    toEnum :: Int -> FilterChange
toEnum Int
0 = FilterChange
FilterChangeDifferent
    toEnum Int
1 = FilterChange
FilterChangeLessStrict
    toEnum Int
2 = FilterChange
FilterChangeMoreStrict
    toEnum Int
k = Int -> FilterChange
AnotherFilterChange Int
k

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

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

foreign import ccall "gtk_filter_change_get_type" c_gtk_filter_change_get_type :: 
    IO GType

instance B.Types.TypedObject FilterChange where
    glibType :: IO GType
glibType = IO GType
c_gtk_filter_change_get_type

instance B.Types.BoxedEnum FilterChange

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

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

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

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

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

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

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

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

foreign import ccall "gtk_file_chooser_error_get_type" c_gtk_file_chooser_error_get_type :: 
    IO GType

instance B.Types.TypedObject FileChooserError where
    glibType :: IO GType
glibType = IO GType
c_gtk_file_chooser_error_get_type

instance B.Types.BoxedEnum FileChooserError

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

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

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

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

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

foreign import ccall "gtk_file_chooser_action_get_type" c_gtk_file_chooser_action_get_type :: 
    IO GType

instance B.Types.TypedObject FileChooserAction where
    glibType :: IO GType
glibType = IO GType
c_gtk_file_chooser_action_get_type

instance B.Types.BoxedEnum FileChooserAction

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

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

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

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

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

foreign import ccall "gtk_event_sequence_state_get_type" c_gtk_event_sequence_state_get_type :: 
    IO GType

instance B.Types.TypedObject EventSequenceState where
    glibType :: IO GType
glibType = IO GType
c_gtk_event_sequence_state_get_type

instance B.Types.BoxedEnum EventSequenceState

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

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

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

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

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

foreign import ccall "gtk_entry_icon_position_get_type" c_gtk_entry_icon_position_get_type :: 
    IO GType

instance B.Types.TypedObject EntryIconPosition where
    glibType :: IO GType
glibType = IO GType
c_gtk_entry_icon_position_get_type

instance B.Types.BoxedEnum EntryIconPosition

-- Enum EditableProperties
-- | /No description available in the introspection data./
data EditableProperties = 
      EditablePropertiesPropText
    -- ^ /No description available in the introspection data./
    | EditablePropertiesPropCursorPosition
    -- ^ /No description available in the introspection data./
    | EditablePropertiesPropSelectionBound
    -- ^ /No description available in the introspection data./
    | EditablePropertiesPropEditable
    -- ^ /No description available in the introspection data./
    | EditablePropertiesPropWidthChars
    -- ^ /No description available in the introspection data./
    | EditablePropertiesPropMaxWidthChars
    -- ^ /No description available in the introspection data./
    | EditablePropertiesPropXalign
    -- ^ /No description available in the introspection data./
    | EditablePropertiesPropEnableUndo
    -- ^ /No description available in the introspection data./
    | EditablePropertiesNumProperties
    -- ^ /No description available in the introspection data./
    | AnotherEditableProperties Int
    -- ^ Catch-all for unknown values
    deriving (Int -> EditableProperties -> ShowS
[EditableProperties] -> ShowS
EditableProperties -> String
(Int -> EditableProperties -> ShowS)
-> (EditableProperties -> String)
-> ([EditableProperties] -> ShowS)
-> Show EditableProperties
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [EditableProperties] -> ShowS
$cshowList :: [EditableProperties] -> ShowS
show :: EditableProperties -> String
$cshow :: EditableProperties -> String
showsPrec :: Int -> EditableProperties -> ShowS
$cshowsPrec :: Int -> EditableProperties -> ShowS
Show, EditableProperties -> EditableProperties -> Bool
(EditableProperties -> EditableProperties -> Bool)
-> (EditableProperties -> EditableProperties -> Bool)
-> Eq EditableProperties
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: EditableProperties -> EditableProperties -> Bool
$c/= :: EditableProperties -> EditableProperties -> Bool
== :: EditableProperties -> EditableProperties -> Bool
$c== :: EditableProperties -> EditableProperties -> Bool
Eq)

instance P.Enum EditableProperties where
    fromEnum :: EditableProperties -> Int
fromEnum EditableProperties
EditablePropertiesPropText = Int
0
    fromEnum EditableProperties
EditablePropertiesPropCursorPosition = Int
1
    fromEnum EditableProperties
EditablePropertiesPropSelectionBound = Int
2
    fromEnum EditableProperties
EditablePropertiesPropEditable = Int
3
    fromEnum EditableProperties
EditablePropertiesPropWidthChars = Int
4
    fromEnum EditableProperties
EditablePropertiesPropMaxWidthChars = Int
5
    fromEnum EditableProperties
EditablePropertiesPropXalign = Int
6
    fromEnum EditableProperties
EditablePropertiesPropEnableUndo = Int
7
    fromEnum EditableProperties
EditablePropertiesNumProperties = Int
8
    fromEnum (AnotherEditableProperties Int
k) = Int
k

    toEnum :: Int -> EditableProperties
toEnum Int
0 = EditableProperties
EditablePropertiesPropText
    toEnum Int
1 = EditableProperties
EditablePropertiesPropCursorPosition
    toEnum Int
2 = EditableProperties
EditablePropertiesPropSelectionBound
    toEnum Int
3 = EditableProperties
EditablePropertiesPropEditable
    toEnum Int
4 = EditableProperties
EditablePropertiesPropWidthChars
    toEnum Int
5 = EditableProperties
EditablePropertiesPropMaxWidthChars
    toEnum Int
6 = EditableProperties
EditablePropertiesPropXalign
    toEnum Int
7 = EditableProperties
EditablePropertiesPropEnableUndo
    toEnum Int
8 = EditableProperties
EditablePropertiesNumProperties
    toEnum Int
k = Int -> EditableProperties
AnotherEditableProperties Int
k

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

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

foreign import ccall "gtk_editable_properties_get_type" c_gtk_editable_properties_get_type :: 
    IO GType

instance B.Types.TypedObject EditableProperties where
    glibType :: IO GType
glibType = IO GType
c_gtk_editable_properties_get_type

instance B.Types.BoxedEnum EditableProperties

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

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

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

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

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

foreign import ccall "gtk_direction_type_get_type" c_gtk_direction_type_get_type :: 
    IO GType

instance B.Types.TypedObject DirectionType where
    glibType :: IO GType
glibType = IO GType
c_gtk_direction_type_get_type

instance B.Types.BoxedEnum DirectionType

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

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

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

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

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

foreign import ccall "gtk_delete_type_get_type" c_gtk_delete_type_get_type :: 
    IO GType

instance B.Types.TypedObject DeleteType where
    glibType :: IO GType
glibType = IO GType
c_gtk_delete_type_get_type

instance B.Types.BoxedEnum DeleteType

-- Enum CssParserWarning
-- | Warnings that can occur while parsing CSS.
-- 
-- Unlike @/GtkCssParserErrors/@, warnings do not cause the parser to
-- skip any input, but they indicate issues that should be fixed.
data CssParserWarning = 
      CssParserWarningDeprecated
    -- ^ The given construct is
    --     deprecated and will be removed in a future version
    | CssParserWarningSyntax
    -- ^ A syntax construct was used
    --     that should be avoided
    | CssParserWarningUnimplemented
    -- ^ A feature is not
    --     implemented
    | AnotherCssParserWarning Int
    -- ^ Catch-all for unknown values
    deriving (Int -> CssParserWarning -> ShowS
[CssParserWarning] -> ShowS
CssParserWarning -> String
(Int -> CssParserWarning -> ShowS)
-> (CssParserWarning -> String)
-> ([CssParserWarning] -> ShowS)
-> Show CssParserWarning
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CssParserWarning] -> ShowS
$cshowList :: [CssParserWarning] -> ShowS
show :: CssParserWarning -> String
$cshow :: CssParserWarning -> String
showsPrec :: Int -> CssParserWarning -> ShowS
$cshowsPrec :: Int -> CssParserWarning -> ShowS
Show, CssParserWarning -> CssParserWarning -> Bool
(CssParserWarning -> CssParserWarning -> Bool)
-> (CssParserWarning -> CssParserWarning -> Bool)
-> Eq CssParserWarning
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CssParserWarning -> CssParserWarning -> Bool
$c/= :: CssParserWarning -> CssParserWarning -> Bool
== :: CssParserWarning -> CssParserWarning -> Bool
$c== :: CssParserWarning -> CssParserWarning -> Bool
Eq)

instance P.Enum CssParserWarning where
    fromEnum :: CssParserWarning -> Int
fromEnum CssParserWarning
CssParserWarningDeprecated = Int
0
    fromEnum CssParserWarning
CssParserWarningSyntax = Int
1
    fromEnum CssParserWarning
CssParserWarningUnimplemented = Int
2
    fromEnum (AnotherCssParserWarning Int
k) = Int
k

    toEnum :: Int -> CssParserWarning
toEnum Int
0 = CssParserWarning
CssParserWarningDeprecated
    toEnum Int
1 = CssParserWarning
CssParserWarningSyntax
    toEnum Int
2 = CssParserWarning
CssParserWarningUnimplemented
    toEnum Int
k = Int -> CssParserWarning
AnotherCssParserWarning Int
k

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

-- Enum CssParserError
-- | Errors that can occur while parsing CSS.
-- 
-- These errors are unexpected and will cause parts of the given CSS
-- to be ignored.
data CssParserError = 
      CssParserErrorFailed
    -- ^ Unknown failure.
    | CssParserErrorSyntax
    -- ^ The given text does not form valid
    --     syntax
    | CssParserErrorImport
    -- ^ Failed to import a resource
    | CssParserErrorName
    -- ^ The given name has not been defined
    | CssParserErrorUnknownValue
    -- ^ The given value is not
    --     correct
    | AnotherCssParserError Int
    -- ^ Catch-all for unknown values
    deriving (Int -> CssParserError -> ShowS
[CssParserError] -> ShowS
CssParserError -> String
(Int -> CssParserError -> ShowS)
-> (CssParserError -> String)
-> ([CssParserError] -> ShowS)
-> Show CssParserError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CssParserError] -> ShowS
$cshowList :: [CssParserError] -> ShowS
show :: CssParserError -> String
$cshow :: CssParserError -> String
showsPrec :: Int -> CssParserError -> ShowS
$cshowsPrec :: Int -> CssParserError -> ShowS
Show, CssParserError -> CssParserError -> Bool
(CssParserError -> CssParserError -> Bool)
-> (CssParserError -> CssParserError -> Bool) -> Eq CssParserError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CssParserError -> CssParserError -> Bool
$c/= :: CssParserError -> CssParserError -> Bool
== :: CssParserError -> CssParserError -> Bool
$c== :: CssParserError -> CssParserError -> Bool
Eq)

instance P.Enum CssParserError where
    fromEnum :: CssParserError -> Int
fromEnum CssParserError
CssParserErrorFailed = Int
0
    fromEnum CssParserError
CssParserErrorSyntax = Int
1
    fromEnum CssParserError
CssParserErrorImport = Int
2
    fromEnum CssParserError
CssParserErrorName = Int
3
    fromEnum CssParserError
CssParserErrorUnknownValue = Int
4
    fromEnum (AnotherCssParserError Int
k) = Int
k

    toEnum :: Int -> CssParserError
toEnum Int
0 = CssParserError
CssParserErrorFailed
    toEnum Int
1 = CssParserError
CssParserErrorSyntax
    toEnum Int
2 = CssParserError
CssParserErrorImport
    toEnum Int
3 = CssParserError
CssParserErrorName
    toEnum Int
4 = CssParserError
CssParserErrorUnknownValue
    toEnum Int
k = Int -> CssParserError
AnotherCssParserError Int
k

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

instance GErrorClass CssParserError where
    gerrorClassDomain :: CssParserError -> Text
gerrorClassDomain CssParserError
_ = Text
"gtk-css-parser-error-quark"

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

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

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

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

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

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

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

foreign import ccall "gtk_corner_type_get_type" c_gtk_corner_type_get_type :: 
    IO GType

instance B.Types.TypedObject CornerType where
    glibType :: IO GType
glibType = IO GType
c_gtk_corner_type_get_type

instance B.Types.BoxedEnum CornerType

-- Enum ConstraintVflParserError
-- | Domain for VFL parsing errors.
data ConstraintVflParserError = 
      ConstraintVflParserErrorSymbol
    -- ^ Invalid or unknown symbol
    | ConstraintVflParserErrorAttribute
    -- ^ Invalid or unknown attribute
    | ConstraintVflParserErrorView
    -- ^ Invalid or unknown view
    | ConstraintVflParserErrorMetric
    -- ^ Invalid or unknown metric
    | ConstraintVflParserErrorPriority
    -- ^ Invalid or unknown priority
    | ConstraintVflParserErrorRelation
    -- ^ Invalid or unknown relation
    | AnotherConstraintVflParserError Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ConstraintVflParserError -> ShowS
[ConstraintVflParserError] -> ShowS
ConstraintVflParserError -> String
(Int -> ConstraintVflParserError -> ShowS)
-> (ConstraintVflParserError -> String)
-> ([ConstraintVflParserError] -> ShowS)
-> Show ConstraintVflParserError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ConstraintVflParserError] -> ShowS
$cshowList :: [ConstraintVflParserError] -> ShowS
show :: ConstraintVflParserError -> String
$cshow :: ConstraintVflParserError -> String
showsPrec :: Int -> ConstraintVflParserError -> ShowS
$cshowsPrec :: Int -> ConstraintVflParserError -> ShowS
Show, ConstraintVflParserError -> ConstraintVflParserError -> Bool
(ConstraintVflParserError -> ConstraintVflParserError -> Bool)
-> (ConstraintVflParserError -> ConstraintVflParserError -> Bool)
-> Eq ConstraintVflParserError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ConstraintVflParserError -> ConstraintVflParserError -> Bool
$c/= :: ConstraintVflParserError -> ConstraintVflParserError -> Bool
== :: ConstraintVflParserError -> ConstraintVflParserError -> Bool
$c== :: ConstraintVflParserError -> ConstraintVflParserError -> Bool
Eq)

instance P.Enum ConstraintVflParserError where
    fromEnum :: ConstraintVflParserError -> Int
fromEnum ConstraintVflParserError
ConstraintVflParserErrorSymbol = Int
0
    fromEnum ConstraintVflParserError
ConstraintVflParserErrorAttribute = Int
1
    fromEnum ConstraintVflParserError
ConstraintVflParserErrorView = Int
2
    fromEnum ConstraintVflParserError
ConstraintVflParserErrorMetric = Int
3
    fromEnum ConstraintVflParserError
ConstraintVflParserErrorPriority = Int
4
    fromEnum ConstraintVflParserError
ConstraintVflParserErrorRelation = Int
5
    fromEnum (AnotherConstraintVflParserError Int
k) = Int
k

    toEnum :: Int -> ConstraintVflParserError
toEnum Int
0 = ConstraintVflParserError
ConstraintVflParserErrorSymbol
    toEnum Int
1 = ConstraintVflParserError
ConstraintVflParserErrorAttribute
    toEnum Int
2 = ConstraintVflParserError
ConstraintVflParserErrorView
    toEnum Int
3 = ConstraintVflParserError
ConstraintVflParserErrorMetric
    toEnum Int
4 = ConstraintVflParserError
ConstraintVflParserErrorPriority
    toEnum Int
5 = ConstraintVflParserError
ConstraintVflParserErrorRelation
    toEnum Int
k = Int -> ConstraintVflParserError
AnotherConstraintVflParserError Int
k

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

instance GErrorClass ConstraintVflParserError where
    gerrorClassDomain :: ConstraintVflParserError -> Text
gerrorClassDomain ConstraintVflParserError
_ = Text
"gtk-constraint-vfl-parser-error-quark"

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

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

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

foreign import ccall "gtk_constraint_vfl_parser_error_get_type" c_gtk_constraint_vfl_parser_error_get_type :: 
    IO GType

instance B.Types.TypedObject ConstraintVflParserError where
    glibType :: IO GType
glibType = IO GType
c_gtk_constraint_vfl_parser_error_get_type

instance B.Types.BoxedEnum ConstraintVflParserError

-- Enum ConstraintStrength
-- | The strength of a constraint, expressed as a symbolic constant.
-- 
-- The strength of a t'GI.Gtk.Objects.Constraint.Constraint' can be expressed with any positive
-- integer; the values of this enumeration can be used for readability.
data ConstraintStrength = 
      ConstraintStrengthRequired
    -- ^ The constraint is required towards solving the layout
    | ConstraintStrengthStrong
    -- ^ A strong constraint
    | ConstraintStrengthMedium
    -- ^ A medium constraint
    | ConstraintStrengthWeak
    -- ^ A weak constraint
    | AnotherConstraintStrength Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ConstraintStrength -> ShowS
[ConstraintStrength] -> ShowS
ConstraintStrength -> String
(Int -> ConstraintStrength -> ShowS)
-> (ConstraintStrength -> String)
-> ([ConstraintStrength] -> ShowS)
-> Show ConstraintStrength
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ConstraintStrength] -> ShowS
$cshowList :: [ConstraintStrength] -> ShowS
show :: ConstraintStrength -> String
$cshow :: ConstraintStrength -> String
showsPrec :: Int -> ConstraintStrength -> ShowS
$cshowsPrec :: Int -> ConstraintStrength -> ShowS
Show, ConstraintStrength -> ConstraintStrength -> Bool
(ConstraintStrength -> ConstraintStrength -> Bool)
-> (ConstraintStrength -> ConstraintStrength -> Bool)
-> Eq ConstraintStrength
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ConstraintStrength -> ConstraintStrength -> Bool
$c/= :: ConstraintStrength -> ConstraintStrength -> Bool
== :: ConstraintStrength -> ConstraintStrength -> Bool
$c== :: ConstraintStrength -> ConstraintStrength -> Bool
Eq)

instance P.Enum ConstraintStrength where
    fromEnum :: ConstraintStrength -> Int
fromEnum ConstraintStrength
ConstraintStrengthRequired = Int
1001001000
    fromEnum ConstraintStrength
ConstraintStrengthStrong = Int
1000000000
    fromEnum ConstraintStrength
ConstraintStrengthMedium = Int
1000
    fromEnum ConstraintStrength
ConstraintStrengthWeak = Int
1
    fromEnum (AnotherConstraintStrength Int
k) = Int
k

    toEnum :: Int -> ConstraintStrength
toEnum Int
1001001000 = ConstraintStrength
ConstraintStrengthRequired
    toEnum Int
1000000000 = ConstraintStrength
ConstraintStrengthStrong
    toEnum Int
1000 = ConstraintStrength
ConstraintStrengthMedium
    toEnum Int
1 = ConstraintStrength
ConstraintStrengthWeak
    toEnum Int
k = Int -> ConstraintStrength
AnotherConstraintStrength Int
k

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

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

foreign import ccall "gtk_constraint_strength_get_type" c_gtk_constraint_strength_get_type :: 
    IO GType

instance B.Types.TypedObject ConstraintStrength where
    glibType :: IO GType
glibType = IO GType
c_gtk_constraint_strength_get_type

instance B.Types.BoxedEnum ConstraintStrength

-- Enum ConstraintRelation
-- | The relation between two terms of a constraint.
data ConstraintRelation = 
      ConstraintRelationLe
    -- ^ Less than, or equal
    | ConstraintRelationEq
    -- ^ Equal
    | ConstraintRelationGe
    -- ^ Greater than, or equal
    | AnotherConstraintRelation Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ConstraintRelation -> ShowS
[ConstraintRelation] -> ShowS
ConstraintRelation -> String
(Int -> ConstraintRelation -> ShowS)
-> (ConstraintRelation -> String)
-> ([ConstraintRelation] -> ShowS)
-> Show ConstraintRelation
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ConstraintRelation] -> ShowS
$cshowList :: [ConstraintRelation] -> ShowS
show :: ConstraintRelation -> String
$cshow :: ConstraintRelation -> String
showsPrec :: Int -> ConstraintRelation -> ShowS
$cshowsPrec :: Int -> ConstraintRelation -> ShowS
Show, ConstraintRelation -> ConstraintRelation -> Bool
(ConstraintRelation -> ConstraintRelation -> Bool)
-> (ConstraintRelation -> ConstraintRelation -> Bool)
-> Eq ConstraintRelation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ConstraintRelation -> ConstraintRelation -> Bool
$c/= :: ConstraintRelation -> ConstraintRelation -> Bool
== :: ConstraintRelation -> ConstraintRelation -> Bool
$c== :: ConstraintRelation -> ConstraintRelation -> Bool
Eq)

instance P.Enum ConstraintRelation where
    fromEnum :: ConstraintRelation -> Int
fromEnum ConstraintRelation
ConstraintRelationLe = Int
-1
    fromEnum ConstraintRelation
ConstraintRelationEq = Int
0
    fromEnum ConstraintRelation
ConstraintRelationGe = Int
1
    fromEnum (AnotherConstraintRelation Int
k) = Int
k

    toEnum :: Int -> ConstraintRelation
toEnum Int
-1 = ConstraintRelation
ConstraintRelationLe
    toEnum Int
0 = ConstraintRelation
ConstraintRelationEq
    toEnum Int
1 = ConstraintRelation
ConstraintRelationGe
    toEnum Int
k = Int -> ConstraintRelation
AnotherConstraintRelation Int
k

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

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

foreign import ccall "gtk_constraint_relation_get_type" c_gtk_constraint_relation_get_type :: 
    IO GType

instance B.Types.TypedObject ConstraintRelation where
    glibType :: IO GType
glibType = IO GType
c_gtk_constraint_relation_get_type

instance B.Types.BoxedEnum ConstraintRelation

-- Enum ConstraintAttribute
-- | The widget attributes that can be used when creating a t'GI.Gtk.Objects.Constraint.Constraint'.
data ConstraintAttribute = 
      ConstraintAttributeNone
    -- ^ No attribute, used for constant
    --   relations
    | ConstraintAttributeLeft
    -- ^ The left edge of a widget, regardless of
    --   text direction
    | ConstraintAttributeRight
    -- ^ The right edge of a widget, regardless
    --   of text direction
    | ConstraintAttributeTop
    -- ^ The top edge of a widget
    | ConstraintAttributeBottom
    -- ^ The bottom edge of a widget
    | ConstraintAttributeStart
    -- ^ The leading edge of a widget, depending
    --   on text direction; equivalent to 'GI.Gtk.Enums.ConstraintAttributeLeft' for LTR
    --   languages, and 'GI.Gtk.Enums.ConstraintAttributeRight' for RTL ones
    | ConstraintAttributeEnd
    -- ^ The trailing edge of a widget, depending
    --   on text direction; equivalent to 'GI.Gtk.Enums.ConstraintAttributeRight' for LTR
    --   languages, and 'GI.Gtk.Enums.ConstraintAttributeLeft' for RTL ones
    | ConstraintAttributeWidth
    -- ^ The width of a widget
    | ConstraintAttributeHeight
    -- ^ The height of a widget
    | ConstraintAttributeCenterX
    -- ^ The center of a widget, on the
    --   horizontal axis
    | ConstraintAttributeCenterY
    -- ^ The center of a widget, on the
    --   vertical axis
    | ConstraintAttributeBaseline
    -- ^ The baseline of a widget
    | AnotherConstraintAttribute Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ConstraintAttribute -> ShowS
[ConstraintAttribute] -> ShowS
ConstraintAttribute -> String
(Int -> ConstraintAttribute -> ShowS)
-> (ConstraintAttribute -> String)
-> ([ConstraintAttribute] -> ShowS)
-> Show ConstraintAttribute
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ConstraintAttribute] -> ShowS
$cshowList :: [ConstraintAttribute] -> ShowS
show :: ConstraintAttribute -> String
$cshow :: ConstraintAttribute -> String
showsPrec :: Int -> ConstraintAttribute -> ShowS
$cshowsPrec :: Int -> ConstraintAttribute -> ShowS
Show, ConstraintAttribute -> ConstraintAttribute -> Bool
(ConstraintAttribute -> ConstraintAttribute -> Bool)
-> (ConstraintAttribute -> ConstraintAttribute -> Bool)
-> Eq ConstraintAttribute
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ConstraintAttribute -> ConstraintAttribute -> Bool
$c/= :: ConstraintAttribute -> ConstraintAttribute -> Bool
== :: ConstraintAttribute -> ConstraintAttribute -> Bool
$c== :: ConstraintAttribute -> ConstraintAttribute -> Bool
Eq)

instance P.Enum ConstraintAttribute where
    fromEnum :: ConstraintAttribute -> Int
fromEnum ConstraintAttribute
ConstraintAttributeNone = Int
0
    fromEnum ConstraintAttribute
ConstraintAttributeLeft = Int
1
    fromEnum ConstraintAttribute
ConstraintAttributeRight = Int
2
    fromEnum ConstraintAttribute
ConstraintAttributeTop = Int
3
    fromEnum ConstraintAttribute
ConstraintAttributeBottom = Int
4
    fromEnum ConstraintAttribute
ConstraintAttributeStart = Int
5
    fromEnum ConstraintAttribute
ConstraintAttributeEnd = Int
6
    fromEnum ConstraintAttribute
ConstraintAttributeWidth = Int
7
    fromEnum ConstraintAttribute
ConstraintAttributeHeight = Int
8
    fromEnum ConstraintAttribute
ConstraintAttributeCenterX = Int
9
    fromEnum ConstraintAttribute
ConstraintAttributeCenterY = Int
10
    fromEnum ConstraintAttribute
ConstraintAttributeBaseline = Int
11
    fromEnum (AnotherConstraintAttribute Int
k) = Int
k

    toEnum :: Int -> ConstraintAttribute
toEnum Int
0 = ConstraintAttribute
ConstraintAttributeNone
    toEnum Int
1 = ConstraintAttribute
ConstraintAttributeLeft
    toEnum Int
2 = ConstraintAttribute
ConstraintAttributeRight
    toEnum Int
3 = ConstraintAttribute
ConstraintAttributeTop
    toEnum Int
4 = ConstraintAttribute
ConstraintAttributeBottom
    toEnum Int
5 = ConstraintAttribute
ConstraintAttributeStart
    toEnum Int
6 = ConstraintAttribute
ConstraintAttributeEnd
    toEnum Int
7 = ConstraintAttribute
ConstraintAttributeWidth
    toEnum Int
8 = ConstraintAttribute
ConstraintAttributeHeight
    toEnum Int
9 = ConstraintAttribute
ConstraintAttributeCenterX
    toEnum Int
10 = ConstraintAttribute
ConstraintAttributeCenterY
    toEnum Int
11 = ConstraintAttribute
ConstraintAttributeBaseline
    toEnum Int
k = Int -> ConstraintAttribute
AnotherConstraintAttribute Int
k

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

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

foreign import ccall "gtk_constraint_attribute_get_type" c_gtk_constraint_attribute_get_type :: 
    IO GType

instance B.Types.TypedObject ConstraintAttribute where
    glibType :: IO GType
glibType = IO GType
c_gtk_constraint_attribute_get_type

instance B.Types.BoxedEnum ConstraintAttribute

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

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

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

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

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

foreign import ccall "gtk_cell_renderer_mode_get_type" c_gtk_cell_renderer_mode_get_type :: 
    IO GType

instance B.Types.TypedObject CellRendererMode where
    glibType :: IO GType
glibType = IO GType
c_gtk_cell_renderer_mode_get_type

instance B.Types.BoxedEnum CellRendererMode

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

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

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

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

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

foreign import ccall "gtk_cell_renderer_accel_mode_get_type" c_gtk_cell_renderer_accel_mode_get_type :: 
    IO GType

instance B.Types.TypedObject CellRendererAccelMode where
    glibType :: IO GType
glibType = IO GType
c_gtk_cell_renderer_accel_mode_get_type

instance B.Types.BoxedEnum CellRendererAccelMode

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

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

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

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

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

foreign import ccall "gtk_buttons_type_get_type" c_gtk_buttons_type_get_type :: 
    IO GType

instance B.Types.TypedObject ButtonsType where
    glibType :: IO GType
glibType = IO GType
c_gtk_buttons_type_get_type

instance B.Types.BoxedEnum ButtonsType

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

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

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

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

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

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

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

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

foreign import ccall "gtk_builder_error_get_type" c_gtk_builder_error_get_type :: 
    IO GType

instance B.Types.TypedObject BuilderError where
    glibType :: IO GType
glibType = IO GType
c_gtk_builder_error_get_type

instance B.Types.BoxedEnum BuilderError

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

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

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

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

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

foreign import ccall "gtk_border_style_get_type" c_gtk_border_style_get_type :: 
    IO GType

instance B.Types.TypedObject BorderStyle where
    glibType :: IO GType
glibType = IO GType
c_gtk_border_style_get_type

instance B.Types.BoxedEnum BorderStyle

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

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

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

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

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

foreign import ccall "gtk_baseline_position_get_type" c_gtk_baseline_position_get_type :: 
    IO GType

instance B.Types.TypedObject BaselinePosition where
    glibType :: IO GType
glibType = IO GType
c_gtk_baseline_position_get_type

instance B.Types.BoxedEnum BaselinePosition

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

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

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

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

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

foreign import ccall "gtk_assistant_page_type_get_type" c_gtk_assistant_page_type_get_type :: 
    IO GType

instance B.Types.TypedObject AssistantPageType where
    glibType :: IO GType
glibType = IO GType
c_gtk_assistant_page_type_get_type

instance B.Types.BoxedEnum AssistantPageType

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

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

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

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

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

foreign import ccall "gtk_arrow_type_get_type" c_gtk_arrow_type_get_type :: 
    IO GType

instance B.Types.TypedObject ArrowType where
    glibType :: IO GType
glibType = IO GType
c_gtk_arrow_type_get_type

instance B.Types.BoxedEnum ArrowType

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

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

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

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

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

foreign import ccall "gtk_align_get_type" c_gtk_align_get_type :: 
    IO GType

instance B.Types.TypedObject Align where
    glibType :: IO GType
glibType = IO GType
c_gtk_align_get_type

instance B.Types.BoxedEnum Align

-- Enum AccessibleTristate
-- | The possible values for the 'GI.Gtk.Enums.AccessibleStatePressed'
-- accessible state.
-- 
-- Note that the 'GI.Gtk.Enums.AccessibleTristateFalse' and
-- 'GI.Gtk.Enums.AccessibleTristateTrue' have the same values
-- as 'P.False' and 'P.True'.
data AccessibleTristate = 
      AccessibleTristateFalse
    -- ^ The state is @false@
    | AccessibleTristateTrue
    -- ^ The state is @true@
    | AccessibleTristateMixed
    -- ^ The state is @mixed@
    | AnotherAccessibleTristate Int
    -- ^ Catch-all for unknown values
    deriving (Int -> AccessibleTristate -> ShowS
[AccessibleTristate] -> ShowS
AccessibleTristate -> String
(Int -> AccessibleTristate -> ShowS)
-> (AccessibleTristate -> String)
-> ([AccessibleTristate] -> ShowS)
-> Show AccessibleTristate
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AccessibleTristate] -> ShowS
$cshowList :: [AccessibleTristate] -> ShowS
show :: AccessibleTristate -> String
$cshow :: AccessibleTristate -> String
showsPrec :: Int -> AccessibleTristate -> ShowS
$cshowsPrec :: Int -> AccessibleTristate -> ShowS
Show, AccessibleTristate -> AccessibleTristate -> Bool
(AccessibleTristate -> AccessibleTristate -> Bool)
-> (AccessibleTristate -> AccessibleTristate -> Bool)
-> Eq AccessibleTristate
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AccessibleTristate -> AccessibleTristate -> Bool
$c/= :: AccessibleTristate -> AccessibleTristate -> Bool
== :: AccessibleTristate -> AccessibleTristate -> Bool
$c== :: AccessibleTristate -> AccessibleTristate -> Bool
Eq)

instance P.Enum AccessibleTristate where
    fromEnum :: AccessibleTristate -> Int
fromEnum AccessibleTristate
AccessibleTristateFalse = Int
0
    fromEnum AccessibleTristate
AccessibleTristateTrue = Int
1
    fromEnum AccessibleTristate
AccessibleTristateMixed = Int
2
    fromEnum (AnotherAccessibleTristate Int
k) = Int
k

    toEnum :: Int -> AccessibleTristate
toEnum Int
0 = AccessibleTristate
AccessibleTristateFalse
    toEnum Int
1 = AccessibleTristate
AccessibleTristateTrue
    toEnum Int
2 = AccessibleTristate
AccessibleTristateMixed
    toEnum Int
k = Int -> AccessibleTristate
AnotherAccessibleTristate Int
k

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

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

foreign import ccall "gtk_accessible_tristate_get_type" c_gtk_accessible_tristate_get_type :: 
    IO GType

instance B.Types.TypedObject AccessibleTristate where
    glibType :: IO GType
glibType = IO GType
c_gtk_accessible_tristate_get_type

instance B.Types.BoxedEnum AccessibleTristate

-- Enum AccessibleState
-- | The possible accessible states of a t'GI.Gtk.Interfaces.Accessible.Accessible'.
data AccessibleState = 
      AccessibleStateBusy
    -- ^ A “busy” state. This state has boolean values
    | AccessibleStateChecked
    -- ^ A “checked” state; indicates the current
    --   state of a t'GI.Gtk.Objects.CheckButton.CheckButton'. Value type: t'GI.Gtk.Enums.AccessibleTristate'
    | AccessibleStateDisabled
    -- ^ A “disabled” state; corresponds to the
    --   t'GI.Gtk.Objects.Widget.Widget':@/sensitive/@ property on t'GI.Gtk.Objects.Widget.Widget'. It indicates a UI element
    --   that is perceivable, but not editable or operable. Value type: boolean
    | AccessibleStateExpanded
    -- ^ An “expanded” state; corresponds to the
    --   t'GI.Gtk.Objects.Expander.Expander':@/expanded/@ property on t'GI.Gtk.Objects.Expander.Expander'. Value type: boolean
    --   or undefined
    | AccessibleStateHidden
    -- ^ A “hidden” state; corresponds to the
    --   t'GI.Gtk.Objects.Widget.Widget':@/visible/@ property on t'GI.Gtk.Objects.Widget.Widget'. You can use this state
    --   explicitly on UI elements that should not be exposed to an assistive
    --   technology. Value type: boolean
    --   See also: 'GI.Gtk.Enums.AccessibleStateDisabled'
    | AccessibleStateInvalid
    -- ^ An “invalid” state; set when a widget
    --   is showing an error. Value type: t'GI.Gtk.Enums.AccessibleInvalidState'
    | AccessibleStatePressed
    -- ^ A “pressed” state; indicates the current
    --   state of a t'GI.Gtk.Objects.ToggleButton.ToggleButton'. Value type: t'GI.Gtk.Enums.AccessibleTristate'
    --   enumeration
    | AccessibleStateSelected
    -- ^ A “selected” state; set when a widget
    --   is selected. Value type: boolean or undefined
    | AnotherAccessibleState Int
    -- ^ Catch-all for unknown values
    deriving (Int -> AccessibleState -> ShowS
[AccessibleState] -> ShowS
AccessibleState -> String
(Int -> AccessibleState -> ShowS)
-> (AccessibleState -> String)
-> ([AccessibleState] -> ShowS)
-> Show AccessibleState
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AccessibleState] -> ShowS
$cshowList :: [AccessibleState] -> ShowS
show :: AccessibleState -> String
$cshow :: AccessibleState -> String
showsPrec :: Int -> AccessibleState -> ShowS
$cshowsPrec :: Int -> AccessibleState -> ShowS
Show, AccessibleState -> AccessibleState -> Bool
(AccessibleState -> AccessibleState -> Bool)
-> (AccessibleState -> AccessibleState -> Bool)
-> Eq AccessibleState
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AccessibleState -> AccessibleState -> Bool
$c/= :: AccessibleState -> AccessibleState -> Bool
== :: AccessibleState -> AccessibleState -> Bool
$c== :: AccessibleState -> AccessibleState -> Bool
Eq)

instance P.Enum AccessibleState where
    fromEnum :: AccessibleState -> Int
fromEnum AccessibleState
AccessibleStateBusy = Int
0
    fromEnum AccessibleState
AccessibleStateChecked = Int
1
    fromEnum AccessibleState
AccessibleStateDisabled = Int
2
    fromEnum AccessibleState
AccessibleStateExpanded = Int
3
    fromEnum AccessibleState
AccessibleStateHidden = Int
4
    fromEnum AccessibleState
AccessibleStateInvalid = Int
5
    fromEnum AccessibleState
AccessibleStatePressed = Int
6
    fromEnum AccessibleState
AccessibleStateSelected = Int
7
    fromEnum (AnotherAccessibleState Int
k) = Int
k

    toEnum :: Int -> AccessibleState
toEnum Int
0 = AccessibleState
AccessibleStateBusy
    toEnum Int
1 = AccessibleState
AccessibleStateChecked
    toEnum Int
2 = AccessibleState
AccessibleStateDisabled
    toEnum Int
3 = AccessibleState
AccessibleStateExpanded
    toEnum Int
4 = AccessibleState
AccessibleStateHidden
    toEnum Int
5 = AccessibleState
AccessibleStateInvalid
    toEnum Int
6 = AccessibleState
AccessibleStatePressed
    toEnum Int
7 = AccessibleState
AccessibleStateSelected
    toEnum Int
k = Int -> AccessibleState
AnotherAccessibleState Int
k

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

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

foreign import ccall "gtk_accessible_state_get_type" c_gtk_accessible_state_get_type :: 
    IO GType

instance B.Types.TypedObject AccessibleState where
    glibType :: IO GType
glibType = IO GType
c_gtk_accessible_state_get_type

instance B.Types.BoxedEnum AccessibleState

-- Enum AccessibleSort
-- | The possible values for the 'GI.Gtk.Enums.AccessiblePropertySort'
-- accessible property.
data AccessibleSort = 
      AccessibleSortNone
    -- ^ There is no defined sort applied to the column.
    | AccessibleSortAscending
    -- ^ Items are sorted in ascending order by this column.
    | AccessibleSortDescending
    -- ^ Items are sorted in descending order by this column.
    | AccessibleSortOther
    -- ^ A sort algorithm other than ascending or
    --    descending has been applied.
    | AnotherAccessibleSort Int
    -- ^ Catch-all for unknown values
    deriving (Int -> AccessibleSort -> ShowS
[AccessibleSort] -> ShowS
AccessibleSort -> String
(Int -> AccessibleSort -> ShowS)
-> (AccessibleSort -> String)
-> ([AccessibleSort] -> ShowS)
-> Show AccessibleSort
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AccessibleSort] -> ShowS
$cshowList :: [AccessibleSort] -> ShowS
show :: AccessibleSort -> String
$cshow :: AccessibleSort -> String
showsPrec :: Int -> AccessibleSort -> ShowS
$cshowsPrec :: Int -> AccessibleSort -> ShowS
Show, AccessibleSort -> AccessibleSort -> Bool
(AccessibleSort -> AccessibleSort -> Bool)
-> (AccessibleSort -> AccessibleSort -> Bool) -> Eq AccessibleSort
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AccessibleSort -> AccessibleSort -> Bool
$c/= :: AccessibleSort -> AccessibleSort -> Bool
== :: AccessibleSort -> AccessibleSort -> Bool
$c== :: AccessibleSort -> AccessibleSort -> Bool
Eq)

instance P.Enum AccessibleSort where
    fromEnum :: AccessibleSort -> Int
fromEnum AccessibleSort
AccessibleSortNone = Int
0
    fromEnum AccessibleSort
AccessibleSortAscending = Int
1
    fromEnum AccessibleSort
AccessibleSortDescending = Int
2
    fromEnum AccessibleSort
AccessibleSortOther = Int
3
    fromEnum (AnotherAccessibleSort Int
k) = Int
k

    toEnum :: Int -> AccessibleSort
toEnum Int
0 = AccessibleSort
AccessibleSortNone
    toEnum Int
1 = AccessibleSort
AccessibleSortAscending
    toEnum Int
2 = AccessibleSort
AccessibleSortDescending
    toEnum Int
3 = AccessibleSort
AccessibleSortOther
    toEnum Int
k = Int -> AccessibleSort
AnotherAccessibleSort Int
k

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

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

foreign import ccall "gtk_accessible_sort_get_type" c_gtk_accessible_sort_get_type :: 
    IO GType

instance B.Types.TypedObject AccessibleSort where
    glibType :: IO GType
glibType = IO GType
c_gtk_accessible_sort_get_type

instance B.Types.BoxedEnum AccessibleSort

-- Enum AccessibleRole
-- | The accessible role for a t'GI.Gtk.Interfaces.Accessible.Accessible' implementation.
-- 
-- Abstract roles are only used as part of the ontology; application
-- developers must not use abstract roles in their code.
data AccessibleRole = 
      AccessibleRoleAlert
    -- ^ An element with important, and usually
    --   time-sensitive, information
    | AccessibleRoleAlertDialog
    -- ^ A type of dialog that contains an
    --   alert message
    | AccessibleRoleBanner
    -- ^ Unused
    | AccessibleRoleButton
    -- ^ An input element that allows for
    --   user-triggered actions when clicked or pressed
    | AccessibleRoleCaption
    -- ^ Unused
    | AccessibleRoleCell
    -- ^ Unused
    | AccessibleRoleCheckbox
    -- ^ A checkable input element that has
    --   three possible values: @true@, @false@, or @mixed@
    | AccessibleRoleColumnHeader
    -- ^ A header in a columned list.
    | AccessibleRoleComboBox
    -- ^ An input that controls another element,
    --   such as a list or a grid, that can dynamically pop up to help the user
    --   set the value of the input
    | AccessibleRoleCommand
    -- ^ Abstract role.
    | AccessibleRoleComposite
    -- ^ Abstract role.
    | AccessibleRoleDialog
    -- ^ A dialog is a window that is designed to interrupt
    --    the current processing of an application in order to prompt the user to enter
    --    information or require a response.
    | AccessibleRoleDocument
    -- ^ Unused
    | AccessibleRoleFeed
    -- ^ Unused
    | AccessibleRoleForm
    -- ^ Unused
    | AccessibleRoleGeneric
    -- ^ Unused
    | AccessibleRoleGrid
    -- ^ A grid of items.
    | AccessibleRoleGridCell
    -- ^ An item in a grid or tree grid.
    | AccessibleRoleGroup
    -- ^ An element that groups multiple widgets. GTK uses
    --   this role for various containers, like t'GI.Gtk.Objects.Box.Box', t'GI.Gtk.Objects.Viewport.Viewport', and t'GI.Gtk.Objects.HeaderBar.HeaderBar'.
    | AccessibleRoleHeading
    -- ^ Unused
    | AccessibleRoleImg
    -- ^ An image.
    | AccessibleRoleInput
    -- ^ Abstract role.
    | AccessibleRoleLabel
    -- ^ A visible name or caption for a user interface component.
    | AccessibleRoleLandmark
    -- ^ Abstract role.
    | AccessibleRoleLegend
    -- ^ Unused
    | AccessibleRoleLink
    -- ^ A clickable link.
    | AccessibleRoleList
    -- ^ A list of items.
    | AccessibleRoleListBox
    -- ^ Unused.
    | AccessibleRoleListItem
    -- ^ An item in a list.
    | AccessibleRoleLog
    -- ^ Unused
    | AccessibleRoleMain
    -- ^ Unused
    | AccessibleRoleMarquee
    -- ^ Unused
    | AccessibleRoleMath
    -- ^ Unused
    | AccessibleRoleMeter
    -- ^ An element that represents a value within a known range.
    | AccessibleRoleMenu
    -- ^ A menu.
    | AccessibleRoleMenuBar
    -- ^ A menubar.
    | AccessibleRoleMenuItem
    -- ^ An item in a menu.
    | AccessibleRoleMenuItemCheckbox
    -- ^ A check item in a menu.
    | AccessibleRoleMenuItemRadio
    -- ^ A radio item in a menu.
    | AccessibleRoleNavigation
    -- ^ Unused
    | AccessibleRoleNone
    -- ^ An element that is not represented to accessibility technologies.
    | AccessibleRoleNote
    -- ^ Unused
    | AccessibleRoleOption
    -- ^ Unused
    | AccessibleRolePresentation
    -- ^ An element that is not represented to accessibility technologies.
    | AccessibleRoleProgressBar
    -- ^ An element that displays the progress
    --    status for tasks that take a long time.
    | AccessibleRoleRadio
    -- ^ A checkable input in a group of radio roles,
    --    only one of which can be checked at a time.
    | AccessibleRoleRadioGroup
    -- ^ Unused
    | AccessibleRoleRange
    -- ^ Abstract role.
    | AccessibleRoleRegion
    -- ^ Unused
    | AccessibleRoleRow
    -- ^ A row in a columned list.
    | AccessibleRoleRowGroup
    -- ^ Unused
    | AccessibleRoleRowHeader
    -- ^ Unused
    | AccessibleRoleScrollbar
    -- ^ A graphical object that controls the scrolling
    --    of content within a viewing area, regardless of whether the content is fully
    --    displayed within the viewing area.
    | AccessibleRoleSearch
    -- ^ Unused
    | AccessibleRoleSearchBox
    -- ^ A type of textbox intended for specifying
    --    search criteria.
    | AccessibleRoleSection
    -- ^ Abstract role.
    | AccessibleRoleSectionHead
    -- ^ Abstract role.
    | AccessibleRoleSelect
    -- ^ Abstract role.
    | AccessibleRoleSeparator
    -- ^ A divider that separates and distinguishes
    --    sections of content or groups of menuitems.
    | AccessibleRoleSlider
    -- ^ A user input where the user selects a value
    --    from within a given range.
    | AccessibleRoleSpinButton
    -- ^ A form of range that expects the user to
    --    select from among discrete choices.
    | AccessibleRoleStatus
    -- ^ Unused
    | AccessibleRoleStructure
    -- ^ Abstract role.
    | AccessibleRoleSwitch
    -- ^ A type of checkbox that represents on\/off values,
    --    as opposed to checked\/unchecked values.
    | AccessibleRoleTab
    -- ^ An item in a list of tab used for switching pages.
    | AccessibleRoleTable
    -- ^ Unused
    | AccessibleRoleTabList
    -- ^ A list of tabs for switching pages.
    | AccessibleRoleTabPanel
    -- ^ A page in a notebook or stack.
    | AccessibleRoleTextBox
    -- ^ A type of input that allows free-form text
    --    as its value.
    | AccessibleRoleTime
    -- ^ Unused
    | AccessibleRoleTimer
    -- ^ Unused
    | AccessibleRoleToolbar
    -- ^ Unused
    | AccessibleRoleTooltip
    -- ^ Unused
    | AccessibleRoleTree
    -- ^ Unused
    | AccessibleRoleTreeGrid
    -- ^ A treeview-like, columned list.
    | AccessibleRoleTreeItem
    -- ^ Unused
    | AccessibleRoleWidget
    -- ^ An interactive component of a graphical user
    --    interface. This is the role that GTK uses by default for widgets.
    | AccessibleRoleWindow
    -- ^ An application window.
    | AnotherAccessibleRole Int
    -- ^ Catch-all for unknown values
    deriving (Int -> AccessibleRole -> ShowS
[AccessibleRole] -> ShowS
AccessibleRole -> String
(Int -> AccessibleRole -> ShowS)
-> (AccessibleRole -> String)
-> ([AccessibleRole] -> ShowS)
-> Show AccessibleRole
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AccessibleRole] -> ShowS
$cshowList :: [AccessibleRole] -> ShowS
show :: AccessibleRole -> String
$cshow :: AccessibleRole -> String
showsPrec :: Int -> AccessibleRole -> ShowS
$cshowsPrec :: Int -> AccessibleRole -> ShowS
Show, AccessibleRole -> AccessibleRole -> Bool
(AccessibleRole -> AccessibleRole -> Bool)
-> (AccessibleRole -> AccessibleRole -> Bool) -> Eq AccessibleRole
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AccessibleRole -> AccessibleRole -> Bool
$c/= :: AccessibleRole -> AccessibleRole -> Bool
== :: AccessibleRole -> AccessibleRole -> Bool
$c== :: AccessibleRole -> AccessibleRole -> Bool
Eq)

instance P.Enum AccessibleRole where
    fromEnum :: AccessibleRole -> Int
fromEnum AccessibleRole
AccessibleRoleAlert = Int
0
    fromEnum AccessibleRole
AccessibleRoleAlertDialog = Int
1
    fromEnum AccessibleRole
AccessibleRoleBanner = Int
2
    fromEnum AccessibleRole
AccessibleRoleButton = Int
3
    fromEnum AccessibleRole
AccessibleRoleCaption = Int
4
    fromEnum AccessibleRole
AccessibleRoleCell = Int
5
    fromEnum AccessibleRole
AccessibleRoleCheckbox = Int
6
    fromEnum AccessibleRole
AccessibleRoleColumnHeader = Int
7
    fromEnum AccessibleRole
AccessibleRoleComboBox = Int
8
    fromEnum AccessibleRole
AccessibleRoleCommand = Int
9
    fromEnum AccessibleRole
AccessibleRoleComposite = Int
10
    fromEnum AccessibleRole
AccessibleRoleDialog = Int
11
    fromEnum AccessibleRole
AccessibleRoleDocument = Int
12
    fromEnum AccessibleRole
AccessibleRoleFeed = Int
13
    fromEnum AccessibleRole
AccessibleRoleForm = Int
14
    fromEnum AccessibleRole
AccessibleRoleGeneric = Int
15
    fromEnum AccessibleRole
AccessibleRoleGrid = Int
16
    fromEnum AccessibleRole
AccessibleRoleGridCell = Int
17
    fromEnum AccessibleRole
AccessibleRoleGroup = Int
18
    fromEnum AccessibleRole
AccessibleRoleHeading = Int
19
    fromEnum AccessibleRole
AccessibleRoleImg = Int
20
    fromEnum AccessibleRole
AccessibleRoleInput = Int
21
    fromEnum AccessibleRole
AccessibleRoleLabel = Int
22
    fromEnum AccessibleRole
AccessibleRoleLandmark = Int
23
    fromEnum AccessibleRole
AccessibleRoleLegend = Int
24
    fromEnum AccessibleRole
AccessibleRoleLink = Int
25
    fromEnum AccessibleRole
AccessibleRoleList = Int
26
    fromEnum AccessibleRole
AccessibleRoleListBox = Int
27
    fromEnum AccessibleRole
AccessibleRoleListItem = Int
28
    fromEnum AccessibleRole
AccessibleRoleLog = Int
29
    fromEnum AccessibleRole
AccessibleRoleMain = Int
30
    fromEnum AccessibleRole
AccessibleRoleMarquee = Int
31
    fromEnum AccessibleRole
AccessibleRoleMath = Int
32
    fromEnum AccessibleRole
AccessibleRoleMeter = Int
33
    fromEnum AccessibleRole
AccessibleRoleMenu = Int
34
    fromEnum AccessibleRole
AccessibleRoleMenuBar = Int
35
    fromEnum AccessibleRole
AccessibleRoleMenuItem = Int
36
    fromEnum AccessibleRole
AccessibleRoleMenuItemCheckbox = Int
37
    fromEnum AccessibleRole
AccessibleRoleMenuItemRadio = Int
38
    fromEnum AccessibleRole
AccessibleRoleNavigation = Int
39
    fromEnum AccessibleRole
AccessibleRoleNone = Int
40
    fromEnum AccessibleRole
AccessibleRoleNote = Int
41
    fromEnum AccessibleRole
AccessibleRoleOption = Int
42
    fromEnum AccessibleRole
AccessibleRolePresentation = Int
43
    fromEnum AccessibleRole
AccessibleRoleProgressBar = Int
44
    fromEnum AccessibleRole
AccessibleRoleRadio = Int
45
    fromEnum AccessibleRole
AccessibleRoleRadioGroup = Int
46
    fromEnum AccessibleRole
AccessibleRoleRange = Int
47
    fromEnum AccessibleRole
AccessibleRoleRegion = Int
48
    fromEnum AccessibleRole
AccessibleRoleRow = Int
49
    fromEnum AccessibleRole
AccessibleRoleRowGroup = Int
50
    fromEnum AccessibleRole
AccessibleRoleRowHeader = Int
51
    fromEnum AccessibleRole
AccessibleRoleScrollbar = Int
52
    fromEnum AccessibleRole
AccessibleRoleSearch = Int
53
    fromEnum AccessibleRole
AccessibleRoleSearchBox = Int
54
    fromEnum AccessibleRole
AccessibleRoleSection = Int
55
    fromEnum AccessibleRole
AccessibleRoleSectionHead = Int
56
    fromEnum AccessibleRole
AccessibleRoleSelect = Int
57
    fromEnum AccessibleRole
AccessibleRoleSeparator = Int
58
    fromEnum AccessibleRole
AccessibleRoleSlider = Int
59
    fromEnum AccessibleRole
AccessibleRoleSpinButton = Int
60
    fromEnum AccessibleRole
AccessibleRoleStatus = Int
61
    fromEnum AccessibleRole
AccessibleRoleStructure = Int
62
    fromEnum AccessibleRole
AccessibleRoleSwitch = Int
63
    fromEnum AccessibleRole
AccessibleRoleTab = Int
64
    fromEnum AccessibleRole
AccessibleRoleTable = Int
65
    fromEnum AccessibleRole
AccessibleRoleTabList = Int
66
    fromEnum AccessibleRole
AccessibleRoleTabPanel = Int
67
    fromEnum AccessibleRole
AccessibleRoleTextBox = Int
68
    fromEnum AccessibleRole
AccessibleRoleTime = Int
69
    fromEnum AccessibleRole
AccessibleRoleTimer = Int
70
    fromEnum AccessibleRole
AccessibleRoleToolbar = Int
71
    fromEnum AccessibleRole
AccessibleRoleTooltip = Int
72
    fromEnum AccessibleRole
AccessibleRoleTree = Int
73
    fromEnum AccessibleRole
AccessibleRoleTreeGrid = Int
74
    fromEnum AccessibleRole
AccessibleRoleTreeItem = Int
75
    fromEnum AccessibleRole
AccessibleRoleWidget = Int
76
    fromEnum AccessibleRole
AccessibleRoleWindow = Int
77
    fromEnum (AnotherAccessibleRole Int
k) = Int
k

    toEnum :: Int -> AccessibleRole
toEnum Int
0 = AccessibleRole
AccessibleRoleAlert
    toEnum Int
1 = AccessibleRole
AccessibleRoleAlertDialog
    toEnum Int
2 = AccessibleRole
AccessibleRoleBanner
    toEnum Int
3 = AccessibleRole
AccessibleRoleButton
    toEnum Int
4 = AccessibleRole
AccessibleRoleCaption
    toEnum Int
5 = AccessibleRole
AccessibleRoleCell
    toEnum Int
6 = AccessibleRole
AccessibleRoleCheckbox
    toEnum Int
7 = AccessibleRole
AccessibleRoleColumnHeader
    toEnum Int
8 = AccessibleRole
AccessibleRoleComboBox
    toEnum Int
9 = AccessibleRole
AccessibleRoleCommand
    toEnum Int
10 = AccessibleRole
AccessibleRoleComposite
    toEnum Int
11 = AccessibleRole
AccessibleRoleDialog
    toEnum Int
12 = AccessibleRole
AccessibleRoleDocument
    toEnum Int
13 = AccessibleRole
AccessibleRoleFeed
    toEnum Int
14 = AccessibleRole
AccessibleRoleForm
    toEnum Int
15 = AccessibleRole
AccessibleRoleGeneric
    toEnum Int
16 = AccessibleRole
AccessibleRoleGrid
    toEnum Int
17 = AccessibleRole
AccessibleRoleGridCell
    toEnum Int
18 = AccessibleRole
AccessibleRoleGroup
    toEnum Int
19 = AccessibleRole
AccessibleRoleHeading
    toEnum Int
20 = AccessibleRole
AccessibleRoleImg
    toEnum Int
21 = AccessibleRole
AccessibleRoleInput
    toEnum Int
22 = AccessibleRole
AccessibleRoleLabel
    toEnum Int
23 = AccessibleRole
AccessibleRoleLandmark
    toEnum Int
24 = AccessibleRole
AccessibleRoleLegend
    toEnum Int
25 = AccessibleRole
AccessibleRoleLink
    toEnum Int
26 = AccessibleRole
AccessibleRoleList
    toEnum Int
27 = AccessibleRole
AccessibleRoleListBox
    toEnum Int
28 = AccessibleRole
AccessibleRoleListItem
    toEnum Int
29 = AccessibleRole
AccessibleRoleLog
    toEnum Int
30 = AccessibleRole
AccessibleRoleMain
    toEnum Int
31 = AccessibleRole
AccessibleRoleMarquee
    toEnum Int
32 = AccessibleRole
AccessibleRoleMath
    toEnum Int
33 = AccessibleRole
AccessibleRoleMeter
    toEnum Int
34 = AccessibleRole
AccessibleRoleMenu
    toEnum Int
35 = AccessibleRole
AccessibleRoleMenuBar
    toEnum Int
36 = AccessibleRole
AccessibleRoleMenuItem
    toEnum Int
37 = AccessibleRole
AccessibleRoleMenuItemCheckbox
    toEnum Int
38 = AccessibleRole
AccessibleRoleMenuItemRadio
    toEnum Int
39 = AccessibleRole
AccessibleRoleNavigation
    toEnum Int
40 = AccessibleRole
AccessibleRoleNone
    toEnum Int
41 = AccessibleRole
AccessibleRoleNote
    toEnum Int
42 = AccessibleRole
AccessibleRoleOption
    toEnum Int
43 = AccessibleRole
AccessibleRolePresentation
    toEnum Int
44 = AccessibleRole
AccessibleRoleProgressBar
    toEnum Int
45 = AccessibleRole
AccessibleRoleRadio
    toEnum Int
46 = AccessibleRole
AccessibleRoleRadioGroup
    toEnum Int
47 = AccessibleRole
AccessibleRoleRange
    toEnum Int
48 = AccessibleRole
AccessibleRoleRegion
    toEnum Int
49 = AccessibleRole
AccessibleRoleRow
    toEnum Int
50 = AccessibleRole
AccessibleRoleRowGroup
    toEnum Int
51 = AccessibleRole
AccessibleRoleRowHeader
    toEnum Int
52 = AccessibleRole
AccessibleRoleScrollbar
    toEnum Int
53 = AccessibleRole
AccessibleRoleSearch
    toEnum Int
54 = AccessibleRole
AccessibleRoleSearchBox
    toEnum Int
55 = AccessibleRole
AccessibleRoleSection
    toEnum Int
56 = AccessibleRole
AccessibleRoleSectionHead
    toEnum Int
57 = AccessibleRole
AccessibleRoleSelect
    toEnum Int
58 = AccessibleRole
AccessibleRoleSeparator
    toEnum Int
59 = AccessibleRole
AccessibleRoleSlider
    toEnum Int
60 = AccessibleRole
AccessibleRoleSpinButton
    toEnum Int
61 = AccessibleRole
AccessibleRoleStatus
    toEnum Int
62 = AccessibleRole
AccessibleRoleStructure
    toEnum Int
63 = AccessibleRole
AccessibleRoleSwitch
    toEnum Int
64 = AccessibleRole
AccessibleRoleTab
    toEnum Int
65 = AccessibleRole
AccessibleRoleTable
    toEnum Int
66 = AccessibleRole
AccessibleRoleTabList
    toEnum Int
67 = AccessibleRole
AccessibleRoleTabPanel
    toEnum Int
68 = AccessibleRole
AccessibleRoleTextBox
    toEnum Int
69 = AccessibleRole
AccessibleRoleTime
    toEnum Int
70 = AccessibleRole
AccessibleRoleTimer
    toEnum Int
71 = AccessibleRole
AccessibleRoleToolbar
    toEnum Int
72 = AccessibleRole
AccessibleRoleTooltip
    toEnum Int
73 = AccessibleRole
AccessibleRoleTree
    toEnum Int
74 = AccessibleRole
AccessibleRoleTreeGrid
    toEnum Int
75 = AccessibleRole
AccessibleRoleTreeItem
    toEnum Int
76 = AccessibleRole
AccessibleRoleWidget
    toEnum Int
77 = AccessibleRole
AccessibleRoleWindow
    toEnum Int
k = Int -> AccessibleRole
AnotherAccessibleRole Int
k

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

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

foreign import ccall "gtk_accessible_role_get_type" c_gtk_accessible_role_get_type :: 
    IO GType

instance B.Types.TypedObject AccessibleRole where
    glibType :: IO GType
glibType = IO GType
c_gtk_accessible_role_get_type

instance B.Types.BoxedEnum AccessibleRole

-- Enum AccessibleRelation
-- | The possible accessible relations of a t'GI.Gtk.Interfaces.Accessible.Accessible'.
-- Accessible relations can be references to other widgets,
-- integers or strings.
data AccessibleRelation = 
      AccessibleRelationActiveDescendant
    -- ^ Identifies the currently active
    --    element when focus is on a composite widget, combobox, textbox, group,
    --    or application. Value type: reference
    | AccessibleRelationColCount
    -- ^ Defines the total number of columns
    --    in a table, grid, or treegrid. Value type: integer
    | AccessibleRelationColIndex
    -- ^ Defines an element\'s column index or
    --    position with respect to the total number of columns within a table,
    --    grid, or treegrid. Value type: integer
    | AccessibleRelationColIndexText
    -- ^ Defines a human readable text
    --   alternative of 'GI.Gtk.Enums.AccessibleRelationColIndex'. Value type: string
    | AccessibleRelationColSpan
    -- ^ Defines the number of columns spanned
    --   by a cell or gridcell within a table, grid, or treegrid. Value type: integer
    | AccessibleRelationControls
    -- ^ Identifies the element (or elements) whose
    --    contents or presence are controlled by the current element. Value type: reference
    | AccessibleRelationDescribedBy
    -- ^ Identifies the element (or elements)
    --    that describes the object. Value type: reference
    | AccessibleRelationDetails
    -- ^ Identifies the element (or elements) that
    --    provide additional information related to the object. Value type: reference
    | AccessibleRelationErrorMessage
    -- ^ Identifies the element that provides
    --    an error message for an object. Value type: reference
    | AccessibleRelationFlowTo
    -- ^ Identifies the next element (or elements)
    --    in an alternate reading order of content which, at the user\'s discretion,
    --    allows assistive technology to override the general default of reading in
    --    document source order. Value type: reference
    | AccessibleRelationLabelledBy
    -- ^ Identifies the element (or elements)
    --    that labels the current element. Value type: reference
    | AccessibleRelationOwns
    -- ^ Identifies an element (or elements) in order
    --    to define a visual, functional, or contextual parent\/child relationship
    --    between elements where the widget hierarchy cannot be used to represent
    --    the relationship. Value type: reference
    | AccessibleRelationPosInSet
    -- ^ Defines an element\'s number or position
    --    in the current set of listitems or treeitems. Value type: integer
    | AccessibleRelationRowCount
    -- ^ Defines the total number of rows in a table,
    --    grid, or treegrid. Value type: integer
    | AccessibleRelationRowIndex
    -- ^ Defines an element\'s row index or position
    --    with respect to the total number of rows within a table, grid, or treegrid.
    --    Value type: integer
    | AccessibleRelationRowIndexText
    -- ^ Defines a human readable text
    --    alternative of aria-rowindex. Value type: string
    | AccessibleRelationRowSpan
    -- ^ Defines the number of rows spanned by a
    --    cell or gridcell within a table, grid, or treegrid. Value type: integer
    | AccessibleRelationSetSize
    -- ^ Defines the number of items in the current
    --    set of listitems or treeitems. Value type: integer
    | AnotherAccessibleRelation Int
    -- ^ Catch-all for unknown values
    deriving (Int -> AccessibleRelation -> ShowS
[AccessibleRelation] -> ShowS
AccessibleRelation -> String
(Int -> AccessibleRelation -> ShowS)
-> (AccessibleRelation -> String)
-> ([AccessibleRelation] -> ShowS)
-> Show AccessibleRelation
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AccessibleRelation] -> ShowS
$cshowList :: [AccessibleRelation] -> ShowS
show :: AccessibleRelation -> String
$cshow :: AccessibleRelation -> String
showsPrec :: Int -> AccessibleRelation -> ShowS
$cshowsPrec :: Int -> AccessibleRelation -> ShowS
Show, AccessibleRelation -> AccessibleRelation -> Bool
(AccessibleRelation -> AccessibleRelation -> Bool)
-> (AccessibleRelation -> AccessibleRelation -> Bool)
-> Eq AccessibleRelation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AccessibleRelation -> AccessibleRelation -> Bool
$c/= :: AccessibleRelation -> AccessibleRelation -> Bool
== :: AccessibleRelation -> AccessibleRelation -> Bool
$c== :: AccessibleRelation -> AccessibleRelation -> Bool
Eq)

instance P.Enum AccessibleRelation where
    fromEnum :: AccessibleRelation -> Int
fromEnum AccessibleRelation
AccessibleRelationActiveDescendant = Int
0
    fromEnum AccessibleRelation
AccessibleRelationColCount = Int
1
    fromEnum AccessibleRelation
AccessibleRelationColIndex = Int
2
    fromEnum AccessibleRelation
AccessibleRelationColIndexText = Int
3
    fromEnum AccessibleRelation
AccessibleRelationColSpan = Int
4
    fromEnum AccessibleRelation
AccessibleRelationControls = Int
5
    fromEnum AccessibleRelation
AccessibleRelationDescribedBy = Int
6
    fromEnum AccessibleRelation
AccessibleRelationDetails = Int
7
    fromEnum AccessibleRelation
AccessibleRelationErrorMessage = Int
8
    fromEnum AccessibleRelation
AccessibleRelationFlowTo = Int
9
    fromEnum AccessibleRelation
AccessibleRelationLabelledBy = Int
10
    fromEnum AccessibleRelation
AccessibleRelationOwns = Int
11
    fromEnum AccessibleRelation
AccessibleRelationPosInSet = Int
12
    fromEnum AccessibleRelation
AccessibleRelationRowCount = Int
13
    fromEnum AccessibleRelation
AccessibleRelationRowIndex = Int
14
    fromEnum AccessibleRelation
AccessibleRelationRowIndexText = Int
15
    fromEnum AccessibleRelation
AccessibleRelationRowSpan = Int
16
    fromEnum AccessibleRelation
AccessibleRelationSetSize = Int
17
    fromEnum (AnotherAccessibleRelation Int
k) = Int
k

    toEnum :: Int -> AccessibleRelation
toEnum Int
0 = AccessibleRelation
AccessibleRelationActiveDescendant
    toEnum Int
1 = AccessibleRelation
AccessibleRelationColCount
    toEnum Int
2 = AccessibleRelation
AccessibleRelationColIndex
    toEnum Int
3 = AccessibleRelation
AccessibleRelationColIndexText
    toEnum Int
4 = AccessibleRelation
AccessibleRelationColSpan
    toEnum Int
5 = AccessibleRelation
AccessibleRelationControls
    toEnum Int
6 = AccessibleRelation
AccessibleRelationDescribedBy
    toEnum Int
7 = AccessibleRelation
AccessibleRelationDetails
    toEnum Int
8 = AccessibleRelation
AccessibleRelationErrorMessage
    toEnum Int
9 = AccessibleRelation
AccessibleRelationFlowTo
    toEnum Int
10 = AccessibleRelation
AccessibleRelationLabelledBy
    toEnum Int
11 = AccessibleRelation
AccessibleRelationOwns
    toEnum Int
12 = AccessibleRelation
AccessibleRelationPosInSet
    toEnum Int
13 = AccessibleRelation
AccessibleRelationRowCount
    toEnum Int
14 = AccessibleRelation
AccessibleRelationRowIndex
    toEnum Int
15 = AccessibleRelation
AccessibleRelationRowIndexText
    toEnum Int
16 = AccessibleRelation
AccessibleRelationRowSpan
    toEnum Int
17 = AccessibleRelation
AccessibleRelationSetSize
    toEnum Int
k = Int -> AccessibleRelation
AnotherAccessibleRelation Int
k

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

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

foreign import ccall "gtk_accessible_relation_get_type" c_gtk_accessible_relation_get_type :: 
    IO GType

instance B.Types.TypedObject AccessibleRelation where
    glibType :: IO GType
glibType = IO GType
c_gtk_accessible_relation_get_type

instance B.Types.BoxedEnum AccessibleRelation

-- Enum AccessibleProperty
-- | The possible accessible properties of a t'GI.Gtk.Interfaces.Accessible.Accessible'.
data AccessibleProperty = 
      AccessiblePropertyAutocomplete
    -- ^ Indicates whether inputting text
    --    could trigger display of one or more predictions of the user\'s intended
    --    value for a combobox, searchbox, or textbox and specifies how predictions
    --    would be presented if they were made. Value type: t'GI.Gtk.Enums.AccessibleAutocomplete'
    | AccessiblePropertyDescription
    -- ^ Defines a string value that describes
    --    or annotates the current element. Value type: string
    | AccessiblePropertyHasPopup
    -- ^ Indicates the availability and type of
    --    interactive popup element, such as menu or dialog, that can be triggered
    --    by an element.
    | AccessiblePropertyKeyShortcuts
    -- ^ Indicates keyboard shortcuts that an
    --    author has implemented to activate or give focus to an element. Value type:
    --    string
    | AccessiblePropertyLabel
    -- ^ Defines a string value that labels the current
    --    element. Value type: string
    | AccessiblePropertyLevel
    -- ^ Defines the hierarchical level of an element
    --    within a structure. Value type: integer
    | AccessiblePropertyModal
    -- ^ Indicates whether an element is modal when
    --    displayed. Value type: boolean
    | AccessiblePropertyMultiLine
    -- ^ Indicates whether a text box accepts
    --    multiple lines of input or only a single line. Value type: boolean
    | AccessiblePropertyMultiSelectable
    -- ^ Indicates that the user may select
    --    more than one item from the current selectable descendants. Value type:
    --    boolean
    | AccessiblePropertyOrientation
    -- ^ Indicates whether the element\'s
    --    orientation is horizontal, vertical, or unknown\/ambiguous. Value type:
    --    t'GI.Gtk.Enums.Orientation'
    | AccessiblePropertyPlaceholder
    -- ^ Defines a short hint (a word or short
    --    phrase) intended to aid the user with data entry when the control has no
    --    value. A hint could be a sample value or a brief description of the expected
    --    format. Value type: string
    | AccessiblePropertyReadOnly
    -- ^ Indicates that the element is not editable,
    --    but is otherwise operable. Value type: boolean
    | AccessiblePropertyRequired
    -- ^ Indicates that user input is required on
    --    the element before a form may be submitted. Value type: boolean
    | AccessiblePropertyRoleDescription
    -- ^ Defines a human-readable,
    --    author-localized description for the role of an element. Value type: string
    | AccessiblePropertySort
    -- ^ Indicates if items in a table or grid are
    --    sorted in ascending or descending order. Possible property values are in
    --    the t'GI.Gtk.Enums.AccessibleSort' enumeration. Value type: t'GI.Gtk.Enums.AccessibleSort'
    | AccessiblePropertyValueMax
    -- ^ Defines the maximum allowed value for a
    --    range widget. Value type: double
    | AccessiblePropertyValueMin
    -- ^ Defines the minimum allowed value for a
    --    range widget. Value type: double
    | AccessiblePropertyValueNow
    -- ^ Defines the current value for a range widget.
    --    Value type: double
    | AccessiblePropertyValueText
    -- ^ Defines the human readable text alternative
    --    of aria-valuenow for a range widget. Value type: string
    | AnotherAccessibleProperty Int
    -- ^ Catch-all for unknown values
    deriving (Int -> AccessibleProperty -> ShowS
[AccessibleProperty] -> ShowS
AccessibleProperty -> String
(Int -> AccessibleProperty -> ShowS)
-> (AccessibleProperty -> String)
-> ([AccessibleProperty] -> ShowS)
-> Show AccessibleProperty
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AccessibleProperty] -> ShowS
$cshowList :: [AccessibleProperty] -> ShowS
show :: AccessibleProperty -> String
$cshow :: AccessibleProperty -> String
showsPrec :: Int -> AccessibleProperty -> ShowS
$cshowsPrec :: Int -> AccessibleProperty -> ShowS
Show, AccessibleProperty -> AccessibleProperty -> Bool
(AccessibleProperty -> AccessibleProperty -> Bool)
-> (AccessibleProperty -> AccessibleProperty -> Bool)
-> Eq AccessibleProperty
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AccessibleProperty -> AccessibleProperty -> Bool
$c/= :: AccessibleProperty -> AccessibleProperty -> Bool
== :: AccessibleProperty -> AccessibleProperty -> Bool
$c== :: AccessibleProperty -> AccessibleProperty -> Bool
Eq)

instance P.Enum AccessibleProperty where
    fromEnum :: AccessibleProperty -> Int
fromEnum AccessibleProperty
AccessiblePropertyAutocomplete = Int
0
    fromEnum AccessibleProperty
AccessiblePropertyDescription = Int
1
    fromEnum AccessibleProperty
AccessiblePropertyHasPopup = Int
2
    fromEnum AccessibleProperty
AccessiblePropertyKeyShortcuts = Int
3
    fromEnum AccessibleProperty
AccessiblePropertyLabel = Int
4
    fromEnum AccessibleProperty
AccessiblePropertyLevel = Int
5
    fromEnum AccessibleProperty
AccessiblePropertyModal = Int
6
    fromEnum AccessibleProperty
AccessiblePropertyMultiLine = Int
7
    fromEnum AccessibleProperty
AccessiblePropertyMultiSelectable = Int
8
    fromEnum AccessibleProperty
AccessiblePropertyOrientation = Int
9
    fromEnum AccessibleProperty
AccessiblePropertyPlaceholder = Int
10
    fromEnum AccessibleProperty
AccessiblePropertyReadOnly = Int
11
    fromEnum AccessibleProperty
AccessiblePropertyRequired = Int
12
    fromEnum AccessibleProperty
AccessiblePropertyRoleDescription = Int
13
    fromEnum AccessibleProperty
AccessiblePropertySort = Int
14
    fromEnum AccessibleProperty
AccessiblePropertyValueMax = Int
15
    fromEnum AccessibleProperty
AccessiblePropertyValueMin = Int
16
    fromEnum AccessibleProperty
AccessiblePropertyValueNow = Int
17
    fromEnum AccessibleProperty
AccessiblePropertyValueText = Int
18
    fromEnum (AnotherAccessibleProperty Int
k) = Int
k

    toEnum :: Int -> AccessibleProperty
toEnum Int
0 = AccessibleProperty
AccessiblePropertyAutocomplete
    toEnum Int
1 = AccessibleProperty
AccessiblePropertyDescription
    toEnum Int
2 = AccessibleProperty
AccessiblePropertyHasPopup
    toEnum Int
3 = AccessibleProperty
AccessiblePropertyKeyShortcuts
    toEnum Int
4 = AccessibleProperty
AccessiblePropertyLabel
    toEnum Int
5 = AccessibleProperty
AccessiblePropertyLevel
    toEnum Int
6 = AccessibleProperty
AccessiblePropertyModal
    toEnum Int
7 = AccessibleProperty
AccessiblePropertyMultiLine
    toEnum Int
8 = AccessibleProperty
AccessiblePropertyMultiSelectable
    toEnum Int
9 = AccessibleProperty
AccessiblePropertyOrientation
    toEnum Int
10 = AccessibleProperty
AccessiblePropertyPlaceholder
    toEnum Int
11 = AccessibleProperty
AccessiblePropertyReadOnly
    toEnum Int
12 = AccessibleProperty
AccessiblePropertyRequired
    toEnum Int
13 = AccessibleProperty
AccessiblePropertyRoleDescription
    toEnum Int
14 = AccessibleProperty
AccessiblePropertySort
    toEnum Int
15 = AccessibleProperty
AccessiblePropertyValueMax
    toEnum Int
16 = AccessibleProperty
AccessiblePropertyValueMin
    toEnum Int
17 = AccessibleProperty
AccessiblePropertyValueNow
    toEnum Int
18 = AccessibleProperty
AccessiblePropertyValueText
    toEnum Int
k = Int -> AccessibleProperty
AnotherAccessibleProperty Int
k

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

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

foreign import ccall "gtk_accessible_property_get_type" c_gtk_accessible_property_get_type :: 
    IO GType

instance B.Types.TypedObject AccessibleProperty where
    glibType :: IO GType
glibType = IO GType
c_gtk_accessible_property_get_type

instance B.Types.BoxedEnum AccessibleProperty

-- Enum AccessibleInvalidState
-- | The possible values for the 'GI.Gtk.Enums.AccessibleStateInvalid'
-- accessible state.
-- 
-- Note that the 'GI.Gtk.Enums.AccessibleInvalidStateFalse' and
-- 'GI.Gtk.Enums.AccessibleInvalidStateTrue' have the same values
-- as 'P.False' and 'P.True'.
data AccessibleInvalidState = 
      AccessibleInvalidStateFalse
    -- ^ There are no detected errors in the value
    | AccessibleInvalidStateTrue
    -- ^ The value entered by the user has failed validation
    | AccessibleInvalidStateGrammar
    -- ^ A grammatical error was detected
    | AccessibleInvalidStateSpelling
    -- ^ A spelling error was detected
    | AnotherAccessibleInvalidState Int
    -- ^ Catch-all for unknown values
    deriving (Int -> AccessibleInvalidState -> ShowS
[AccessibleInvalidState] -> ShowS
AccessibleInvalidState -> String
(Int -> AccessibleInvalidState -> ShowS)
-> (AccessibleInvalidState -> String)
-> ([AccessibleInvalidState] -> ShowS)
-> Show AccessibleInvalidState
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AccessibleInvalidState] -> ShowS
$cshowList :: [AccessibleInvalidState] -> ShowS
show :: AccessibleInvalidState -> String
$cshow :: AccessibleInvalidState -> String
showsPrec :: Int -> AccessibleInvalidState -> ShowS
$cshowsPrec :: Int -> AccessibleInvalidState -> ShowS
Show, AccessibleInvalidState -> AccessibleInvalidState -> Bool
(AccessibleInvalidState -> AccessibleInvalidState -> Bool)
-> (AccessibleInvalidState -> AccessibleInvalidState -> Bool)
-> Eq AccessibleInvalidState
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AccessibleInvalidState -> AccessibleInvalidState -> Bool
$c/= :: AccessibleInvalidState -> AccessibleInvalidState -> Bool
== :: AccessibleInvalidState -> AccessibleInvalidState -> Bool
$c== :: AccessibleInvalidState -> AccessibleInvalidState -> Bool
Eq)

instance P.Enum AccessibleInvalidState where
    fromEnum :: AccessibleInvalidState -> Int
fromEnum AccessibleInvalidState
AccessibleInvalidStateFalse = Int
0
    fromEnum AccessibleInvalidState
AccessibleInvalidStateTrue = Int
1
    fromEnum AccessibleInvalidState
AccessibleInvalidStateGrammar = Int
2
    fromEnum AccessibleInvalidState
AccessibleInvalidStateSpelling = Int
3
    fromEnum (AnotherAccessibleInvalidState Int
k) = Int
k

    toEnum :: Int -> AccessibleInvalidState
toEnum Int
0 = AccessibleInvalidState
AccessibleInvalidStateFalse
    toEnum Int
1 = AccessibleInvalidState
AccessibleInvalidStateTrue
    toEnum Int
2 = AccessibleInvalidState
AccessibleInvalidStateGrammar
    toEnum Int
3 = AccessibleInvalidState
AccessibleInvalidStateSpelling
    toEnum Int
k = Int -> AccessibleInvalidState
AnotherAccessibleInvalidState Int
k

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

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

foreign import ccall "gtk_accessible_invalid_state_get_type" c_gtk_accessible_invalid_state_get_type :: 
    IO GType

instance B.Types.TypedObject AccessibleInvalidState where
    glibType :: IO GType
glibType = IO GType
c_gtk_accessible_invalid_state_get_type

instance B.Types.BoxedEnum AccessibleInvalidState

-- Enum AccessibleAutocomplete
-- | The possible values for the 'GI.Gtk.Enums.AccessiblePropertyAutocomplete'
-- accessible property.
data AccessibleAutocomplete = 
      AccessibleAutocompleteNone
    -- ^ Automatic suggestions are not displayed.
    | AccessibleAutocompleteInline
    -- ^ When a user is providing input, text
    --    suggesting one way to complete the provided input may be dynamically
    --    inserted after the caret.
    | AccessibleAutocompleteList
    -- ^ When a user is providing input, an element
    --    containing a collection of values that could complete the provided input
    --    may be displayed.
    | AccessibleAutocompleteBoth
    -- ^ When a user is providing input, an element
    --    containing a collection of values that could complete the provided input
    --    may be displayed. If displayed, one value in the collection is automatically
    --    selected, and the text needed to complete the automatically selected value
    --    appears after the caret in the input.
    | AnotherAccessibleAutocomplete Int
    -- ^ Catch-all for unknown values
    deriving (Int -> AccessibleAutocomplete -> ShowS
[AccessibleAutocomplete] -> ShowS
AccessibleAutocomplete -> String
(Int -> AccessibleAutocomplete -> ShowS)
-> (AccessibleAutocomplete -> String)
-> ([AccessibleAutocomplete] -> ShowS)
-> Show AccessibleAutocomplete
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AccessibleAutocomplete] -> ShowS
$cshowList :: [AccessibleAutocomplete] -> ShowS
show :: AccessibleAutocomplete -> String
$cshow :: AccessibleAutocomplete -> String
showsPrec :: Int -> AccessibleAutocomplete -> ShowS
$cshowsPrec :: Int -> AccessibleAutocomplete -> ShowS
Show, AccessibleAutocomplete -> AccessibleAutocomplete -> Bool
(AccessibleAutocomplete -> AccessibleAutocomplete -> Bool)
-> (AccessibleAutocomplete -> AccessibleAutocomplete -> Bool)
-> Eq AccessibleAutocomplete
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AccessibleAutocomplete -> AccessibleAutocomplete -> Bool
$c/= :: AccessibleAutocomplete -> AccessibleAutocomplete -> Bool
== :: AccessibleAutocomplete -> AccessibleAutocomplete -> Bool
$c== :: AccessibleAutocomplete -> AccessibleAutocomplete -> Bool
Eq)

instance P.Enum AccessibleAutocomplete where
    fromEnum :: AccessibleAutocomplete -> Int
fromEnum AccessibleAutocomplete
AccessibleAutocompleteNone = Int
0
    fromEnum AccessibleAutocomplete
AccessibleAutocompleteInline = Int
1
    fromEnum AccessibleAutocomplete
AccessibleAutocompleteList = Int
2
    fromEnum AccessibleAutocomplete
AccessibleAutocompleteBoth = Int
3
    fromEnum (AnotherAccessibleAutocomplete Int
k) = Int
k

    toEnum :: Int -> AccessibleAutocomplete
toEnum Int
0 = AccessibleAutocomplete
AccessibleAutocompleteNone
    toEnum Int
1 = AccessibleAutocomplete
AccessibleAutocompleteInline
    toEnum Int
2 = AccessibleAutocomplete
AccessibleAutocompleteList
    toEnum Int
3 = AccessibleAutocomplete
AccessibleAutocompleteBoth
    toEnum Int
k = Int -> AccessibleAutocomplete
AnotherAccessibleAutocomplete Int
k

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

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

foreign import ccall "gtk_accessible_autocomplete_get_type" c_gtk_accessible_autocomplete_get_type :: 
    IO GType

instance B.Types.TypedObject AccessibleAutocomplete where
    glibType :: IO GType
glibType = IO GType
c_gtk_accessible_autocomplete_get_type

instance B.Types.BoxedEnum AccessibleAutocomplete