    {-# LINE 2 "./Graphics/UI/Gtk/General/Enums.chs" #-}
    -- -*-haskell-*-
    -- GIMP Toolkit (GTK) Enumerations
    --
    -- Author : Axel Simon, Manuel Chakravarty
    --
    -- Created: 13 January 1999
    --
    -- Copyright (C) 1999..2005 Axel Simon, Manuel Chakravarty
    --
    -- This library is free software; you can redistribute it and/or
    -- modify it under the terms of the GNU Lesser General Public
    -- License as published by the Free Software Foundation; either
    -- version 2.1 of the License, or (at your option) any later version.
    --
    -- This library is distributed in the hope that it will be useful,
    -- but WITHOUT ANY WARRANTY; without even the implied warranty of
    -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
    -- Lesser General Public License for more details.
    --
    -- |
    -- Maintainer : gtk2hs-users@lists.sourceforge.net
    -- Stability : provisional
    -- Portability : portable (depends on GHC)
    --
    -- General enumeration types.
    --
    module Graphics.UI.Gtk.General.Enums (
      AccelFlags(..),

      Align(..),

      ArrowType(..),
      AttachOptions(..),

      BaselinePosition(..),

      MouseButton(..),
      ButtonBoxStyle(..),
      CalendarDisplayOptions(..),
      Click(..),
      CornerType(..),
      DeleteType(..),
      DestDefaults(..),

      DragResult(..),

      DirectionType(..),
      Justification(..),

      LevelBarMode(..),

      MenuDirectionType(..),

      MovementStep(..),
      Orientation(..),
      Packing(..), toPacking, fromPacking,
      PackType(..),
      PathPriorityType(..),
      PathType(..),
      PolicyType(..),
      PositionType(..),

      ReliefStyle(..),
      ResizeMode(..),
      ScrollType(..),
      ScrollStep (..),
      SelectionMode(..),
      ShadowType(..),

      StateFlags(..),

      SortType(..),
      StateType(..),

      SpinButtonUpdatePolicy(..),
      SpinType(..),
      TargetFlags(..),
      TextDirection(..),
      TextSearchFlags(..),
      TextWindowType(..),
      ToolbarStyle(..),
      TreeViewColumnSizing(..),
      --TroughType(..),

      WindowPosition(..),
      WindowType(..),
      WrapMode(..),

      EntryIconPosition(..),

      StackTransitionType (..),

    module Graphics.UI.Gtk.Gdk.Enums
      ) where

    import System.Glib.Flags (Flags)
    import Graphics.UI.Gtk.Gdk.Enums

    {-# LINE 125 "./Graphics/UI/Gtk/General/Enums.chs" #-}

    -- | State of an accelerator
    --
    data AccelFlags = AccelVisible
                    | AccelLocked
                    | AccelMask
                    deriving (AccelFlags
    AccelFlags -> AccelFlags -> Bounded AccelFlags
    forall a. a -> a -> Bounded a
    $cminBound :: AccelFlags
    minBound :: AccelFlags
    $cmaxBound :: AccelFlags
    maxBound :: AccelFlags
    Bounded,AccelFlags -> AccelFlags -> Bool
    (AccelFlags -> AccelFlags -> Bool)
    -> (AccelFlags -> AccelFlags -> Bool) -> Eq AccelFlags
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: AccelFlags -> AccelFlags -> Bool
    == :: AccelFlags -> AccelFlags -> Bool
    $c/= :: AccelFlags -> AccelFlags -> Bool
    /= :: AccelFlags -> AccelFlags -> Bool
    Eq,Int -> AccelFlags -> ShowS
    [AccelFlags] -> ShowS
    AccelFlags -> String
    (Int -> AccelFlags -> ShowS)
    -> (AccelFlags -> String)
    -> ([AccelFlags] -> ShowS)
    -> Show AccelFlags
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> AccelFlags -> ShowS
    showsPrec :: Int -> AccelFlags -> ShowS
    $cshow :: AccelFlags -> String
    show :: AccelFlags -> String
    $cshowList :: [AccelFlags] -> ShowS
    showList :: [AccelFlags] -> ShowS
    Show)
    instance Enum AccelFlags where
      fromEnum AccelVisible = 1
      fromEnum AccelLocked = 2
      fromEnum AccelMask = 7

      toEnum :: Int -> AccelFlags
    toEnum Int
    1 = AccelFlags
    AccelVisible
      toEnum 2 = AccelLocked
      toEnum Int
    7 = AccelFlags
    AccelMask
      toEnum Int
    unmatched = String -> AccelFlags
    forall a. HasCallStack => String -> a
    error (String
    "AccelFlags.toEnum: Cannot match " String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ Int -> String
    forall a. Show a => a -> String
    show Int
    unmatched)

      succ AccelVisible = AccelLocked
      succ AccelLocked = AccelMask
      succ _ = undefined

      pred :: AccelFlags -> AccelFlags
    pred AccelFlags
    AccelLocked = AccelFlags
    AccelVisible
      pred AccelFlags
    AccelMask = AccelFlags
    AccelLocked
      pred AccelFlags
    _ = AccelFlags
    forall a. HasCallStack => a
    undefined

      enumFromTo x y | fromEnum x == fromEnum y = [ y ]
                     | otherwise = x : enumFromTo (succ x) y
      enumFrom x = enumFromTo x AccelMask
      enumFromThen _ _ =     error "Enum AccelFlags: enumFromThen not implemented"
      enumFromThenTo :: AccelFlags -> AccelFlags -> AccelFlags -> [AccelFlags]
    enumFromThenTo AccelFlags
    _ AccelFlags
    _ AccelFlags
    _ =     String -> [AccelFlags]
    forall a. HasCallStack => String -> a
    error String
    "Enum AccelFlags: enumFromThenTo not implemented"

    {-# LINE 130 "./Graphics/UI/Gtk/General/Enums.chs" #-}

    instance Flags AccelFlags

    -- | State of an accelerator
    --
    data Align = AlignFill
               | AlignStart
               | AlignEnd
               | AlignCenter
               | AlignBaseline
               deriving (Enum,Bounded,Eq,Show)

    {-# LINE 137 "./Graphics/UI/Gtk/General/Enums.chs" #-}

    -- | Arrow directions for the arrow widget
    --
    data ArrowType = ArrowUp
                   | ArrowDown
                   | ArrowLeft
                   | ArrowRight
                   | ArrowNone
                   deriving (Enum,Eq,Show)

    {-# LINE 142 "./Graphics/UI/Gtk/General/Enums.chs" #-}

    -- | Child widget attach options for table containers
    --
    data AttachOptions = Expand
                       | Shrink
                       | Fill
                       deriving (Bounded,Eq,Show)
    instance Enum AttachOptions where
      fromEnum Expand = 1
      fromEnum Shrink = 2
      fromEnum Fill = 4

      toEnum 1 = Expand
      toEnum 2 = Shrink
      toEnum 4 = Fill
      toEnum unmatched = error ("AttachOptions.toEnum: Cannot match " ++ show unmatched)

      succ :: AttachOptions -> AttachOptions
    succ AttachOptions
    Expand = AttachOptions
    Shrink
      succ AttachOptions
    Shrink = AttachOptions
    Fill
      succ AttachOptions
    _ = AttachOptions
    forall a. HasCallStack => a
    undefined

      pred :: AttachOptions -> AttachOptions
    pred AttachOptions
    Shrink = AttachOptions
    Expand
      pred AttachOptions
    Fill = AttachOptions
    Shrink
      pred AttachOptions
    _ = AttachOptions
    forall a. HasCallStack => a
    undefined

      enumFromTo x y | fromEnum x == fromEnum y = [ y ]
                     | otherwise = x : enumFromTo (succ x) y
      enumFrom x = enumFromTo x Fill
      enumFromThen _ _ =     error "Enum AttachOptions: enumFromThen not implemented"
      enumFromThenTo _ _ _ =     error "Enum AttachOptions: enumFromThenTo not implemented"

    {-# LINE 146 "./Graphics/UI/Gtk/General/Enums.chs" #-}

    instance Flags AttachOptions

    -- | 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 BaselinePosition to select where to put the
    -- baseline inside the extra available space.
    --
    data BaselinePosition = BaselinePositionTop
                          | BaselinePositionCenter
                          | BaselinePositionBottom
                          deriving (Enum,Eq,Show)

    {-# LINE 157 "./Graphics/UI/Gtk/General/Enums.chs" #-}

    -- | Mouse buttons.
    --
    data MouseButton = LeftButton
                     | MiddleButton
                     | RightButton
                     | OtherButton Int
                       deriving (Eq,Show)

    instance Enum MouseButton where
      toEnum 1 = LeftButton
      toEnum 2 = MiddleButton
      toEnum 3 = RightButton
      toEnum n = OtherButton (fromIntegral n)
      fromEnum LeftButton = 1
      fromEnum MiddleButton = 2
      fromEnum RightButton = 3
      fromEnum (OtherButton n) = fromIntegral n

    -- | Dictate the style that a ButtonBox uses to align it contents
    --
    data ButtonBoxStyle = ButtonboxSpread
                        | ButtonboxEdge
                        | ButtonboxStart
                        | ButtonboxEnd
                        | ButtonboxCenter
                        | ButtonboxExpand
                        deriving (Eq,Show)
    instance Enum ButtonBoxStyle where
      fromEnum ButtonboxSpread = 1
      fromEnum ButtonboxEdge = 2
      fromEnum ButtonboxStart = 3
      fromEnum ButtonboxEnd = 4
      fromEnum ButtonboxCenter = 5
      fromEnum ButtonboxExpand = 6

      toEnum 1 = ButtonboxSpread
      toEnum 2 = ButtonboxEdge
      toEnum 3 = ButtonboxStart
      toEnum 4 = ButtonboxEnd
      toEnum 5 = ButtonboxCenter
      toEnum 6 = ButtonboxExpand
      toEnum unmatched = error ("ButtonBoxStyle.toEnum: Cannot match " ++ show unmatched)

      succ :: ButtonBoxStyle -> ButtonBoxStyle
    succ ButtonBoxStyle
    ButtonboxSpread = ButtonBoxStyle
    ButtonboxEdge
      succ :: CalendarDisplayOptions -> CalendarDisplayOptions
    succ ButtonBoxStyle
    ButtonboxEdge = ButtonBoxStyle
    ButtonboxStart
      succ ButtonBoxStyle
    ButtonboxStart = ButtonBoxStyle
    ButtonboxEnd
      succ ButtonBoxStyle
    ButtonboxEnd = ButtonBoxStyle
    ButtonboxCenter
      succ ButtonBoxStyle
    ButtonboxCenter = ButtonBoxStyle
    ButtonboxExpand
      succ CalendarDisplayOptions
    ButtonBoxStyle
    _ = CalendarDisplayOptions
    ButtonBoxStyle
    forall a. HasCallStack => a
    undefined

      pred :: CalendarDisplayOptions -> CalendarDisplayOptions
    pred :: ButtonBoxStyle -> ButtonBoxStyle
    pred ButtonBoxStyle
    ButtonboxEdge = ButtonBoxStyle
    ButtonboxSpread
      pred ButtonBoxStyle
    ButtonboxStart = ButtonBoxStyle
    ButtonboxEdge
      pred ButtonBoxStyle
    ButtonboxEnd = ButtonBoxStyle
    ButtonboxStart
      pred ButtonBoxStyle
    ButtonboxCenter = ButtonBoxStyle
    ButtonboxEnd
      pred ButtonBoxStyle
    ButtonboxExpand = ButtonBoxStyle
    ButtonboxCenter
      pred ButtonBoxStyle
    _ = ButtonBoxStyle
    forall a. HasCallStack => a
    undefined

      enumFromTo x y | fromEnum x == fromEnum y = [ y ]
                     | otherwise = x : enumFromTo (succ x) y
      enumFrom :: ButtonBoxStyle -> [ButtonBoxStyle]
    enumFrom ButtonBoxStyle
    x = ButtonBoxStyle -> ButtonBoxStyle -> [ButtonBoxStyle]
    forall a. Enum a => a -> a -> [a]
    enumFromTo ButtonBoxStyle
    x ButtonBoxStyle
    ButtonboxExpand
      enumFromThen :: ButtonBoxStyle -> ButtonBoxStyle -> [ButtonBoxStyle]
    enumFromThen ButtonBoxStyle
    _ CalendarDisplayOptions
    ButtonBoxStyle
    _ CalendarDisplayOptions
    =     String -> [ButtonBoxStyle]
    forall a. HasCallStack => String -> a
    error String
    "Enum ButtonBoxStyle: enumFromThen not implemented"
      enumFromThenTo :: ButtonBoxStyle
    -> ButtonBoxStyle -> ButtonBoxStyle -> [ButtonBoxStyle]
    enumFromThenTo ButtonBoxStyle
    _ ButtonBoxStyle
    _ ButtonBoxStyle
    _ =     String -> [ButtonBoxStyle]
    forall a. HasCallStack => String -> a
    error String
    "Enum ButtonBoxStyle: enumFromThenTo not implemented"

    {-# LINE 180 "./Graphics/UI/Gtk/General/Enums.chs" #-}

    -- | Specify which items of a calendar should be displayed.
    --
    data CalendarDisplayOptions = CalendarShowHeading
                                | CalendarShowDayNames
                                | CalendarNoMonthChange
                                | CalendarShowWeekNumbers
                                | CalendarShowDetails
                                deriving (Bounded,Eq,Show)
    instance Enum CalendarDisplayOptions where
      fromEnum CalendarShowHeading = 1
      fromEnum CalendarShowDayNames = 2
      fromEnum CalendarNoMonthChange = 4
      fromEnum CalendarShowWeekNumbers = 8
      fromEnum CalendarShowDetails = 32

      toEnum 1 = CalendarShowHeading
      toEnum 2 = CalendarShowDayNames
      toEnum 4 = CalendarNoMonthChange
      toEnum 8 = CalendarShowWeekNumbers
      toEnum 32 = CalendarShowDetails
      toEnum unmatched = error ("CalendarDisplayOptions.toEnum: Cannot match " ++ show unmatched)

      succ CalendarShowHeading = CalendarShowDayNames
      succ CalendarShowDayNames = CalendarNoMonthChange
      succ CalendarNoMonthChange = CalendarShowWeekNumbers
      succ CalendarShowWeekNumbers = CalendarShowDetails
      succ _ = undefined

      pred CalendarShowDayNames = CalendarShowHeading
      pred CalendarNoMonthChange = CalendarShowDayNames
      pred CalendarShowWeekNumbers = CalendarNoMonthChange
      pred CalendarShowDetails = CalendarShowWeekNumbers
      pred _ = undefined

      enumFromTo x y | fromEnum x == fromEnum y = [ y ]
                     | otherwise = x : enumFromTo (succ x) y
      enumFrom x = enumFromTo x CalendarShowDetails
      enumFromThen _ _ =     error "Enum CalendarDisplayOptions: enumFromThen not implemented"
      enumFromThenTo _ _ _ =     error "Enum CalendarDisplayOptions: enumFromThenTo not implemented"

    {-# LINE 184 "./Graphics/UI/Gtk/General/Enums.chs" #-}

    instance Flags CalendarDisplayOptions

    -- | Type of mouse click
    --
    data Click = SingleClick
               | DoubleClick
               | TripleClick
               | ReleaseClick
      deriving (Eq,Show,Enum)

    -- | Specifies in which corner a child widget should be placed
    --
    data CornerType = CornerTopLeft
                    | CornerBottomLeft
                    | CornerTopRight
                    | CornerBottomRight
                    deriving (Enum,Eq,Show)

    {-# LINE 198 "./Graphics/UI/Gtk/General/Enums.chs" #-}

    -- | Editing option
    --
    data DeleteType = DeleteChars
                    | DeleteWordEnds
                    | DeleteWords
                    | DeleteDisplayLines
                    | DeleteDisplayLineEnds
                    | DeleteParagraphEnds
                    | DeleteParagraphs
                    | DeleteWhitespace
                    deriving (Enum,Eq,Show)

    {-# LINE 202 "./Graphics/UI/Gtk/General/Enums.chs" #-}

    -- | The 'DestDefaults' enumeration specifies the various types of action that
    -- will be taken on behalf of the user for a drag destination site.
    --
    -- * 'DestDefaultMotion': If set for a widget, GTK+, during a drag over this
    -- widget will check if the drag matches this widget's list of possible
    -- targets and actions. GTK+ will then call
    -- 'Graphics.UI.Gtk.Gdk.Drag.dragStatus' as appropriate.
    --
    -- * 'DestDefaultHighlight': If set for a widget, GTK+ will draw a
    -- highlight on this widget as long as a drag is over this widget and the
    -- widget drag format and action are acceptable.
    --
    -- * 'DestDefaultDrop': If set for a widget, when a drop occurs, GTK+ will
    -- will check if the drag matches this widget's list of possible targets and
    -- actions. If so, GTK+ will call 'Graphics.UI.Gtk.Gdk.Drag.dragGetData' on
    -- behalf of the widget. Whether or not the drop is successful, GTK+ will
    -- call 'Graphics.UI.Gtk.Gdk.Drag.dragFinish'. If the action was a move,
    -- then if the drag was successful, then @True@ will be passed for the
    -- delete parameter to 'Graphics.UI.Gtk.Gdk.Drag.dragFinish'
    --
    -- * 'DestDefaultAll': If set, specifies that all default actions should be
    -- taken.
    --
    data DestDefaults = DestDefaultMotion
                      | DestDefaultHighlight
                      | DestDefaultDrop
                      | DestDefaultAll
                      deriving (DestDefaults
    DestDefaults -> DestDefaults -> Bounded DestDefaults
    forall a. a -> a -> Bounded a
    $cminBound :: DestDefaults
    minBound :: DestDefaults
    $cmaxBound :: DestDefaults
    maxBound :: DestDefaults
    Bounded,DestDefaults -> DestDefaults -> Bool
    (DestDefaults -> DestDefaults -> Bool)
    -> (DestDefaults -> DestDefaults -> Bool) -> Eq DestDefaults
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: DestDefaults -> DestDefaults -> Bool
    == :: DestDefaults -> DestDefaults -> Bool
    $c/= :: DestDefaults -> DestDefaults -> Bool
    /= :: DestDefaults -> DestDefaults -> Bool
    Eq,Int -> DestDefaults -> ShowS
    [DestDefaults] -> ShowS
    DestDefaults -> String
    (Int -> DestDefaults -> ShowS)
    -> (DestDefaults -> String)
    -> ([DestDefaults] -> ShowS)
    -> Show DestDefaults
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> DestDefaults -> ShowS
    showsPrec :: Int -> DestDefaults -> ShowS
    $cshow :: DestDefaults -> String
    show :: DestDefaults -> String
    $cshowList :: [DestDefaults] -> ShowS
    showList :: [DestDefaults] -> ShowS
    Show)
    instance Enum DestDefaults where
      fromEnum :: DestDefaults -> Int
    fromEnum DestDefaults
    DestDefaultMotion = Int
    1
      fromEnum DestDefaults
    DestDefaultHighlight = Int
    2
      fromEnum DestDefaults
    DestDefaultDrop = Int
    4
      fromEnum DestDefaults
    DestDefaultAll = Int
    7

      toEnum :: Int -> DestDefaults
    toEnum Int
    1 = DestDefaults
    DestDefaultMotion
      toEnum Int
    2 = DestDefaults
    DestDefaultHighlight
      toEnum Int
    4 = DestDefaults
    DestDefaultDrop
      toEnum Int
    7 = DestDefaults
    DestDefaultAll
      toEnum Int
    unmatched = String -> DestDefaults
    forall a. HasCallStack => String -> a
    error (String
    "DestDefaults.toEnum: Cannot match " String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ Int -> String
    forall a. Show a => a -> String
    show Int
    unmatched)

      succ DestDefaultMotion = DestDefaultHighlight
      succ DestDefaultHighlight = DestDefaultDrop
      succ DestDefaultDrop = DestDefaultAll
      succ _ = undefined

      pred DestDefaultHighlight = DestDefaultMotion
      pred DestDefaultDrop = DestDefaultHighlight
      pred DestDefaultAll = DestDefaultDrop
      pred _ = undefined

      enumFromTo x y | fromEnum x == fromEnum y = [ y ]
                     | otherwise = x : enumFromTo (succ x) y
      enumFrom :: DestDefaults -> [DestDefaults]
    enumFrom DestDefaults
    x = DestDefaults -> DestDefaults -> [DestDefaults]
    forall a. Enum a => a -> a -> [a]
    enumFromTo DestDefaults
    x DestDefaults
    DestDefaultAll
      enumFromThen :: DestDefaults -> DestDefaults -> [DestDefaults]
    enumFromThen DestDefaults
    _ DestDefaults
    _ =     String -> [DestDefaults]
    forall a. HasCallStack => String -> a
    error String
    "Enum DestDefaults: enumFromThen not implemented"
      enumFromThenTo :: DestDefaults -> DestDefaults -> DestDefaults -> [DestDefaults]
    enumFromThenTo DestDefaults
    _ DestDefaults
    _ DestDefaults
    _ =     error "Enum DestDefaults: enumFromThenTo not implemented"

    {-# LINE 227 "./Graphics/UI/Gtk/General/Enums.chs" #-}

    instance Flags DestDefaults

    -- | Gives an indication why a drag operation failed. The value can by
    -- obtained by connecting to the 'dragFailed' signal.
    --
    -- * 'DragResultSuccess': The drag operation was successful
    --
    -- * 'DragResultNoTarget': No suitable drag target
    --
    -- * 'DragResultUserCancelled': The user cancelled the drag operation
    --
    -- * 'DragResultTimeoutExpired': The drag operation timed out
    --
    -- * 'DragResultGrabBroken': The pointer or keyboard grab used for the drag
    -- operation was broken
    --
    -- * 'DragResultError': The drag operation failed due to some unspecified error
    --
    data DragResult = DragResultSuccess
                    | DragResultNoTarget
                    | DragResultUserCancelled
                    | DragResultTimeoutExpired
                    | DragResultGrabBroken
                    | DragResultError
                    deriving (Enum,Bounded,Eq,Show)

    {-# LINE 248 "./Graphics/UI/Gtk/General/Enums.chs" #-}

    -- | Editing direction
    --
    data DirectionType = DirTabForward
                       | DirTabBackward
                       | DirUp
                       | DirDown
                       | DirLeft
                       | DirRight
                       deriving (Enum,Eq,Show)

    {-# LINE 253 "./Graphics/UI/Gtk/General/Enums.chs" #-}

    -- | Justification for label and maybe other widgets (text?)
    --
    data Justification = JustifyLeft
                       | JustifyRight
                       | JustifyCenter
                       | JustifyFill
                       deriving (Enum,Eq,Show)

    {-# LINE 257 "./Graphics/UI/Gtk/General/Enums.chs" #-}

    data LevelBarMode = LevelBarModeContinuous
                      | LevelBarModeDiscrete
                      deriving (Enum,Eq,Show)

    {-# LINE 271 "./Graphics/UI/Gtk/General/Enums.chs" #-}
    -- | From where was a menu item entered?
    --
    data MenuDirectionType = MenuDirParent
                           | MenuDirChild
                           | MenuDirNext
                           | MenuDirPrev
                           deriving (Int -> MenuDirectionType
    MenuDirectionType -> Int
    MenuDirectionType -> [MenuDirectionType]
    MenuDirectionType -> MenuDirectionType
    MenuDirectionType -> MenuDirectionType -> [MenuDirectionType]
    MenuDirectionType
    -> MenuDirectionType -> MenuDirectionType -> [MenuDirectionType]
    (MenuDirectionType -> MenuDirectionType)
    -> (MenuDirectionType -> MenuDirectionType)
    -> (Int -> MenuDirectionType)
    -> (MenuDirectionType -> Int)
    -> (MenuDirectionType -> [MenuDirectionType])
    -> (MenuDirectionType -> MenuDirectionType -> [MenuDirectionType])
    -> (MenuDirectionType -> MenuDirectionType -> [MenuDirectionType])
    -> (MenuDirectionType
        -> MenuDirectionType -> MenuDirectionType -> [MenuDirectionType])
    -> Enum MenuDirectionType
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: MenuDirectionType -> MenuDirectionType
    succ :: MenuDirectionType -> MenuDirectionType
    $cpred :: MenuDirectionType -> MenuDirectionType
    pred :: MenuDirectionType -> MenuDirectionType
    $ctoEnum :: Int -> MenuDirectionType
    toEnum :: Int -> MenuDirectionType
    $cfromEnum :: MenuDirectionType -> Int
    fromEnum :: MenuDirectionType -> Int
    $cenumFrom :: MenuDirectionType -> [MenuDirectionType]
    enumFrom :: MenuDirectionType -> [MenuDirectionType]
    $cenumFromThen :: MenuDirectionType -> MenuDirectionType -> [MenuDirectionType]
    enumFromThen :: MenuDirectionType -> MenuDirectionType -> [MenuDirectionType]
    $cenumFromTo :: MenuDirectionType -> MenuDirectionType -> [MenuDirectionType]
    enumFromTo :: MenuDirectionType -> MenuDirectionType -> [MenuDirectionType]
    $cenumFromThenTo :: MenuDirectionType
    -> MenuDirectionType -> MenuDirectionType -> [MenuDirectionType]
    enumFromThenTo :: MenuDirectionType
    -> MenuDirectionType -> MenuDirectionType -> [MenuDirectionType]
    Enum,MenuDirectionType -> MenuDirectionType -> Bool
    (MenuDirectionType -> MenuDirectionType -> Bool)
    -> (MenuDirectionType -> MenuDirectionType -> Bool)
    -> Eq MenuDirectionType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: MenuDirectionType -> MenuDirectionType -> Bool
    == :: MenuDirectionType -> MenuDirectionType -> Bool
    $c/= :: MenuDirectionType -> MenuDirectionType -> Bool
    /= :: MenuDirectionType -> MenuDirectionType -> Bool
    Eq,Int -> MenuDirectionType -> ShowS
    [MenuDirectionType] -> ShowS
    MenuDirectionType -> String
    (Int -> MenuDirectionType -> ShowS)
    -> (MenuDirectionType -> String)
    -> ([MenuDirectionType] -> ShowS)
    -> Show MenuDirectionType
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> MenuDirectionType -> ShowS
    showsPrec :: Int -> MenuDirectionType -> ShowS
    $cshow :: MenuDirectionType -> String
    show :: MenuDirectionType -> String
    $cshowList :: [MenuDirectionType] -> ShowS
    showList :: [MenuDirectionType] -> ShowS
    Show)

    {-# LINE 282 "./Graphics/UI/Gtk/General/Enums.chs" #-}
    -- | Movement in text widget
    --
    data MovementStep = MovementLogicalPositions
                      | MovementVisualPositions
                      | MovementWords
                      | MovementDisplayLines
                      | MovementDisplayLineEnds
                      | MovementParagraphs
                      | MovementParagraphEnds
                      | MovementPages
                      | MovementBufferEnds
                      | MovementHorizontalPages
                      deriving (Int -> MovementStep
    MovementStep -> Int
    MovementStep -> [MovementStep]
    MovementStep -> MovementStep
    MovementStep -> MovementStep -> [MovementStep]
    MovementStep -> MovementStep -> MovementStep -> [MovementStep]
    (MovementStep -> MovementStep)
    -> (MovementStep -> MovementStep)
    -> (Int -> MovementStep)
    -> (MovementStep -> Int)
    -> (MovementStep -> [MovementStep])
    -> (MovementStep -> MovementStep -> [MovementStep])
    -> (MovementStep -> MovementStep -> [MovementStep])
    -> (MovementStep -> MovementStep -> MovementStep -> [MovementStep])
    -> Enum MovementStep
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: MovementStep -> MovementStep
    succ :: MovementStep -> MovementStep
    $cpred :: MovementStep -> MovementStep
    pred :: MovementStep -> MovementStep
    $ctoEnum :: Int -> MovementStep
    toEnum :: Int -> MovementStep
    $cfromEnum :: MovementStep -> Int
    fromEnum :: MovementStep -> Int
    $cenumFrom :: MovementStep -> [MovementStep]
    enumFrom :: MovementStep -> [MovementStep]
    $cenumFromThen :: MovementStep -> MovementStep -> [MovementStep]
    enumFromThen :: MovementStep -> MovementStep -> [MovementStep]
    $cenumFromTo :: MovementStep -> MovementStep -> [MovementStep]
    enumFromTo :: MovementStep -> MovementStep -> [MovementStep]
    $cenumFromThenTo :: MovementStep -> MovementStep -> MovementStep -> [MovementStep]
    enumFromThenTo :: MovementStep -> MovementStep -> MovementStep -> [MovementStep]
    Enum,MovementStep -> MovementStep -> Bool
    (MovementStep -> MovementStep -> Bool)
    -> (MovementStep -> MovementStep -> Bool) -> Eq MovementStep
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: MovementStep -> MovementStep -> Bool
    == :: MovementStep -> MovementStep -> Bool
    $c/= :: MovementStep -> MovementStep -> Bool
    /= :: MovementStep -> MovementStep -> Bool
    Eq,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
    $cshowsPrec :: Int -> MovementStep -> ShowS
    showsPrec :: Int -> MovementStep -> ShowS
    $cshow :: MovementStep -> String
    show :: MovementStep -> String
    $cshowList :: [MovementStep] -> ShowS
    showList :: [MovementStep] -> ShowS
    Show)

    {-# LINE 285 "./Graphics/UI/Gtk/General/Enums.chs" #-}

    -- | Orientation is good
    --
    data Orientation = OrientationHorizontal
                     | OrientationVertical
                     deriving (Enum,Eq,Show)

    {-# LINE 289 "./Graphics/UI/Gtk/General/Enums.chs" #-}

    -- | Packing parameters of a widget
    --
    -- * The 'Packing' parameter determines how the child behaves in the horizontal
    -- or vertical way in an 'Graphics.UI.Gtk.Layout.HBox' or
    -- 'Graphics.UI.Gtk.Layout.VBox', respectively. 'PackNatural'
    -- means the child is as big as it requests. It will stay at the start or
    -- end of a 'Graphics.UI.Gtk.Layout.Box' if there is more space available.
    -- All children packed with 'PackRepel' will be padded on both sides with
    -- additional space. 'PackGrow' will increase the size of a widget so that it
    -- covers the available space. A menu bar, for instance, should always
    -- stay at the top of a window and should only occupy as little space
    -- as possible. Hence it should be packed at the start of a
    -- 'Graphics.UI.Gtk.Layout.VBox' with
    -- the packing option 'PackNatural'. The working area of a window
    -- (e.g. the text area in an editor) should expand when the window is
    -- resized. Here the packing option 'PackGrow' is the right choice and
    -- it is irrelevant whether the main area is inserted at the start or
    -- the end of a box. Finally 'PackRepel' is most useful in a window
    -- where no widget can make use of excess space. Examples include a
    -- dialog box without list boxes or text fields.
    --
    data Packing = PackRepel
                 | PackGrow
                 | PackNatural
                 deriving (Int -> Packing
    Packing -> Int
    Packing -> [Packing]
    Packing -> Packing
    Packing -> Packing -> [Packing]
    Packing -> Packing -> Packing -> [Packing]
    (Packing -> Packing)
    -> (Packing -> Packing)
    -> (Int -> Packing)
    -> (Packing -> Int)
    -> (Packing -> [Packing])
    -> (Packing -> Packing -> [Packing])
    -> (Packing -> Packing -> [Packing])
    -> (Packing -> Packing -> Packing -> [Packing])
    -> Enum Packing
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: Packing -> Packing
    succ :: Packing -> Packing
    $cpred :: Packing -> Packing
    pred :: Packing -> Packing
    $ctoEnum :: Int -> Packing
    toEnum :: Int -> Packing
    $cfromEnum :: Packing -> Int
    fromEnum :: Packing -> Int
    $cenumFrom :: Packing -> [Packing]
    enumFrom :: Packing -> [Packing]
    $cenumFromThen :: Packing -> Packing -> [Packing]
    enumFromThen :: Packing -> Packing -> [Packing]
    $cenumFromTo :: Packing -> Packing -> [Packing]
    enumFromTo :: Packing -> Packing -> [Packing]
    $cenumFromThenTo :: Packing -> Packing -> Packing -> [Packing]
    enumFromThenTo :: Packing -> Packing -> Packing -> [Packing]
    Enum,Packing -> Packing -> Bool
    (Packing -> Packing -> Bool)
    -> (Packing -> Packing -> Bool) -> Eq Packing
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Packing -> Packing -> Bool
    == :: Packing -> Packing -> Bool
    $c/= :: Packing -> Packing -> Bool
    /= :: Packing -> Packing -> Bool
    Eq,Int -> Packing -> ShowS
    [Packing] -> ShowS
    Packing -> String
    (Int -> Packing -> ShowS)
    -> (Packing -> String) -> ([Packing] -> ShowS) -> Show Packing
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Packing -> ShowS
    showsPrec :: Int -> Packing -> ShowS
    $cshow :: Packing -> String
    show :: Packing -> String
    $cshowList :: [Packing] -> ShowS
    showList :: [Packing] -> ShowS
    Show)

    -- The conversions between our Packing type and Gtk's expand and fill
    -- properties.
    --
    toPacking :: Bool -> Bool -> Packing
    toPacking :: Bool -> Bool -> Packing
    toPacking Bool
    expand Bool
    True = Packing
    PackGrow
    toPacking Bool
    True Bool
    fill = Packing
    PackRepel
    toPacking Bool
    False Bool
    fill = Packing
    PackNatural

    fromPacking :: Packing -> (Bool, Bool)
    fromPacking :: Packing -> (Bool, Bool)
    fromPacking Packing
    PackGrow = (Bool
    True,Bool
    True)
    fromPacking Packing
    PackRepel = (Bool
    True,Bool
    False)
    fromPacking Packing
    PackNatural = (Bool
    False,Bool
    False)

    -- | Packing of widgets at start or end in a box
    --
    data PackType = PackStart
                  | PackEnd
                  deriving (Int -> PackType
    PackType -> Int
    PackType -> [PackType]
    PackType -> PackType
    PackType -> PackType -> [PackType]
    PackType -> PackType -> PackType -> [PackType]
    (PackType -> PackType)
    -> (PackType -> PackType)
    -> (Int -> PackType)
    -> (PackType -> Int)
    -> (PackType -> [PackType])
    -> (PackType -> PackType -> [PackType])
    -> (PackType -> PackType -> [PackType])
    -> (PackType -> PackType -> PackType -> [PackType])
    -> Enum PackType
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: PackType -> PackType
    succ :: PackType -> PackType
    $cpred :: PackType -> PackType
    pred :: PackType -> PackType
    $ctoEnum :: Int -> PackType
    toEnum :: Int -> PackType
    $cfromEnum :: PackType -> Int
    fromEnum :: PackType -> Int
    $cenumFrom :: PackType -> [PackType]
    enumFrom :: PackType -> [PackType]
    $cenumFromThen :: PackType -> PackType -> [PackType]
    enumFromThen :: PackType -> PackType -> [PackType]
    $cenumFromTo :: PackType -> PackType -> [PackType]
    enumFromTo :: PackType -> PackType -> [PackType]
    $cenumFromThenTo :: PackType -> PackType -> PackType -> [PackType]
    enumFromThenTo :: PackType -> PackType -> PackType -> [PackType]
    Enum,PackType -> PackType -> Bool
    (PackType -> PackType -> Bool)
    -> (PackType -> PackType -> Bool) -> Eq PackType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: PackType -> PackType -> Bool
    == :: PackType -> PackType -> Bool
    $c/= :: PackType -> PackType -> Bool
    /= :: PackType -> PackType -> Bool
    Eq,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
    $cshowsPrec :: Int -> PackType -> ShowS
    showsPrec :: Int -> PackType -> ShowS
    $cshow :: PackType -> String
    show :: PackType -> String
    $cshowList :: [PackType] -> ShowS
    showList :: [PackType] -> ShowS
    Show)

    {-# LINE 332 "./Graphics/UI/Gtk/General/Enums.chs" #-}

    -- | Priorities
    --
    data PathPriorityType = PathPrioLowest
                          | PathPrioGtk
                          | PathPrioApplication
                          | PathPrioTheme
                          | PathPrioRc
                          | PathPrioHighest
                          deriving (Eq,Show)
    instance Enum PathPriorityType where
      fromEnum PathPrioLowest = 0
      fromEnum PathPrioGtk = 4
      fromEnum PathPrioApplication = 8
      fromEnum PathPrioTheme = 10
      fromEnum PathPrioRc = 12
      fromEnum PathPrioHighest = 15

      toEnum :: Int -> PathPriorityType
    toEnum Int
    0 = PathPriorityType
    PathPrioLowest
      toEnum Int
    4 = PathPriorityType
    PathPrioGtk
      toEnum Int
    8 = PathPriorityType
    PathPrioApplication
      toEnum Int
    10 = PathPriorityType
    PathPrioTheme
      toEnum Int
    12 = PathPriorityType
    PathPrioRc
      toEnum Int
    15 = PathPriorityType
    PathPrioHighest
      toEnum Int
    unmatched = String -> PathPriorityType
    forall a. HasCallStack => String -> a
    error (String
    "PathPriorityType.toEnum: Cannot match " String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ Int -> String
    forall a. Show a => a -> String
    show Int
    unmatched)

      succ PathPrioLowest = PathPrioGtk
      succ PathPrioGtk = PathPrioApplication
      succ PathPrioApplication = PathPrioTheme
      succ PathPrioTheme = PathPrioRc
      succ PathPrioRc = PathPrioHighest
      succ _ = undefined

      pred :: PathPriorityType -> PathPriorityType
    pred PathPriorityType
    PathPrioGtk = PathPriorityType
    PathPrioLowest
      pred PathPriorityType
    PathPrioApplication = PathPriorityType
    PathPrioGtk
      pred PathPriorityType
    PathPrioTheme = PathPriorityType
    PathPrioApplication
      pred PathPriorityType
    PathPrioRc = PathPriorityType
    PathPrioTheme
      pred PathPriorityType
    PathPrioHighest = PathPriorityType
    PathPrioRc
      pred PathPriorityType
    _ = PathPriorityType
    forall a. HasCallStack => a
    undefined

      enumFromTo x y | fromEnum x == fromEnum y = [ y ]
                     | otherwise = x : enumFromTo (succ x) y
      enumFrom :: PathPriorityType -> [PathPriorityType]
    enumFrom PathPriorityType
    x = PathPriorityType -> PathPriorityType -> [PathPriorityType]
    forall a. Enum a => a -> a -> [a]
    enumFromTo PathPriorityType
    x PathPriorityType
    PathPrioHighest
      enumFromThen :: PathPriorityType -> PathPriorityType -> [PathPriorityType]
    enumFromThen PathPriorityType
    _ PathPriorityType
    _ =     String -> [PathPriorityType]
    forall a. HasCallStack => String -> a
    error String
    "Enum PathPriorityType: enumFromThen not implemented"
      enumFromThenTo :: PathPriorityType
    -> PathPriorityType -> PathPriorityType -> [PathPriorityType]
    enumFromThenTo PathPriorityType
    _ PathPriorityType
    _ PathPriorityType
    _ =     String -> [PathPriorityType]
    forall a. HasCallStack => String -> a
    error String
    "Enum PathPriorityType: enumFromThenTo not implemented"

    {-# LINE 336 "./Graphics/UI/Gtk/General/Enums.chs" #-}

    -- | Widget identification path
    --
    data PathType = PathWidget
                  | PathWidgetClass
                  | PathClass
                  deriving (Enum,Eq,Show)

    {-# LINE 340 "./Graphics/UI/Gtk/General/Enums.chs" #-}

    -- | Scrollbar policy types (for scrolled windows)
    --
    data PolicyType = PolicyAlways
                    | PolicyAutomatic
                    | PolicyNever
                    | PolicyExternal
                    deriving (Enum,Eq,Show)

    {-# LINE 344 "./Graphics/UI/Gtk/General/Enums.chs" #-}

    -- | Position a scale's value is drawn relative to the
    -- through
    --
    data PositionType = PosLeft
                      | PosRight
                      | PosTop
                      | PosBottom
                      deriving (Enum,Eq,Show)

    {-# LINE 358 "./Graphics/UI/Gtk/General/Enums.chs" #-}
    -- | I don't have a clue.
    --
    data ReliefStyle = ReliefNormal
                     | ReliefHalf
                     | ReliefNone
                     deriving (Enum,Eq,Show)

    {-# LINE 361 "./Graphics/UI/Gtk/General/Enums.chs" #-}

    -- | Resize mode, for containers
    --
    -- * 'ResizeParent' Pass resize request to the parent
    --
    -- * 'ResizeQueue' Queue resizes on this widget
    --
    -- * 'ResizeImmediate' Perform the resizes now
    --
    data ResizeMode = ResizeParent
                    | ResizeQueue
                    | ResizeImmediate
                    deriving (Enum,Eq,Show)

    {-# LINE 371 "./Graphics/UI/Gtk/General/Enums.chs" #-}

    -- | Scrolling type
    --
    data ScrollType = ScrollNone
                    | ScrollJump
                    | ScrollStepBackward
                    | ScrollStepForward
                    | ScrollPageBackward
                    | ScrollPageForward
                    | ScrollStepUp
                    | ScrollStepDown
                    | ScrollPageUp
                    | ScrollPageDown
                    | ScrollStepLeft
                    | ScrollStepRight
                    | ScrollPageLeft
                    | ScrollPageRight
                    | ScrollStart
                    | ScrollEnd
                    deriving (Int -> ScrollType
    ScrollType -> Int
    ScrollType -> [ScrollType]
    ScrollType -> ScrollType
    ScrollType -> ScrollType -> [ScrollType]
    ScrollType -> ScrollType -> ScrollType -> [ScrollType]
    (ScrollType -> ScrollType)
    -> (ScrollType -> ScrollType)
    -> (Int -> ScrollType)
    -> (ScrollType -> Int)
    -> (ScrollType -> [ScrollType])
    -> (ScrollType -> ScrollType -> [ScrollType])
    -> (ScrollType -> ScrollType -> [ScrollType])
    -> (ScrollType -> ScrollType -> ScrollType -> [ScrollType])
    -> Enum ScrollType
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: ScrollType -> ScrollType
    succ :: ScrollType -> ScrollType
    $cpred :: ScrollType -> ScrollType
    pred :: ScrollType -> ScrollType
    $ctoEnum :: Int -> ScrollType
    toEnum :: Int -> ScrollType
    $cfromEnum :: ScrollType -> Int
    fromEnum :: ScrollType -> Int
    $cenumFrom :: ScrollType -> [ScrollType]
    enumFrom :: ScrollType -> [ScrollType]
    $cenumFromThen :: ScrollType -> ScrollType -> [ScrollType]
    enumFromThen :: ScrollType -> ScrollType -> [ScrollType]
    $cenumFromTo :: ScrollType -> ScrollType -> [ScrollType]
    enumFromTo :: ScrollType -> ScrollType -> [ScrollType]
    $cenumFromThenTo :: ScrollType -> ScrollType -> ScrollType -> [ScrollType]
    enumFromThenTo :: ScrollType -> ScrollType -> ScrollType -> [ScrollType]
    Enum,ScrollType -> ScrollType -> Bool
    (ScrollType -> ScrollType -> Bool)
    -> (ScrollType -> ScrollType -> Bool) -> Eq ScrollType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ScrollType -> ScrollType -> Bool
    == :: ScrollType -> ScrollType -> Bool
    $c/= :: ScrollType -> ScrollType -> Bool
    /= :: ScrollType -> ScrollType -> Bool
    Eq,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
    $cshowsPrec :: Int -> ScrollType -> ShowS
    showsPrec :: Int -> ScrollType -> ShowS
    $cshow :: ScrollType -> String
    show :: ScrollType -> String
    $cshowList :: [ScrollType] -> ShowS
    showList :: [ScrollType] -> ShowS
    Show)

    {-# LINE 375 "./Graphics/UI/Gtk/General/Enums.chs" #-}

    -- | Scrolling step
    --
    data ScrollStep = ScrollSteps
                    | ScrollPages
                    | ScrollEnds
                    | ScrollHorizontalSteps
                    | ScrollHorizontalPages
                    | ScrollHorizontalEnds
                    deriving (Enum,Eq,Show)

    {-# LINE 379 "./Graphics/UI/Gtk/General/Enums.chs" #-}

    -- | Mode in which selections can be performed
    --
    -- * There is a deprecated entry SelectionExtended which should have the same
    -- value as SelectionMultiple. C2HS chokes on that construct.
    --
    data SelectionMode = SelectionNone
                       | SelectionSingle
                       | SelectionBrowse
                       | SelectionMultiple
                       deriving (Enum,Eq,Show)
    -- {#enum SelectionMode {underscoreToCase} deriving (Eq,Show)#}

    -- | Shadow types
    --
    data ShadowType = ShadowNone
                    | ShadowIn
                    | ShadowOut
                    | ShadowEtchedIn
                    | ShadowEtchedOut
                    deriving (Int -> ShadowType
    ShadowType -> Int
    ShadowType -> [ShadowType]
    ShadowType -> ShadowType
    ShadowType -> ShadowType -> [ShadowType]
    ShadowType -> ShadowType -> ShadowType -> [ShadowType]
    (ShadowType -> ShadowType)
    -> (ShadowType -> ShadowType)
    -> (Int -> ShadowType)
    -> (ShadowType -> Int)
    -> (ShadowType -> [ShadowType])
    -> (ShadowType -> ShadowType -> [ShadowType])
    -> (ShadowType -> ShadowType -> [ShadowType])
    -> (ShadowType -> ShadowType -> ShadowType -> [ShadowType])
    -> Enum ShadowType
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: ShadowType -> ShadowType
    succ :: ShadowType -> ShadowType
    $cpred :: ShadowType -> ShadowType
    pred :: ShadowType -> ShadowType
    $ctoEnum :: Int -> ShadowType
    toEnum :: Int -> ShadowType
    $cfromEnum :: ShadowType -> Int
    fromEnum :: ShadowType -> Int
    $cenumFrom :: ShadowType -> [ShadowType]
    enumFrom :: ShadowType -> [ShadowType]
    $cenumFromThen :: ShadowType -> ShadowType -> [ShadowType]
    enumFromThen :: ShadowType -> ShadowType -> [ShadowType]
    $cenumFromTo :: ShadowType -> ShadowType -> [ShadowType]
    enumFromTo :: ShadowType -> ShadowType -> [ShadowType]
    $cenumFromThenTo :: ShadowType -> ShadowType -> ShadowType -> [ShadowType]
    enumFromThenTo :: ShadowType -> ShadowType -> ShadowType -> [ShadowType]
    Enum,ShadowType -> ShadowType -> Bool
    (ShadowType -> ShadowType -> Bool)
    -> (ShadowType -> ShadowType -> Bool) -> Eq ShadowType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ShadowType -> ShadowType -> Bool
    == :: ShadowType -> ShadowType -> Bool
    $c/= :: ShadowType -> ShadowType -> Bool
    /= :: ShadowType -> ShadowType -> Bool
    Eq,Int -> ShadowType -> ShowS
    [ShadowType] -> ShowS
    ShadowType -> String
    (Int -> ShadowType -> ShowS)
    -> (ShadowType -> String)
    -> ([ShadowType] -> ShowS)
    -> Show ShadowType
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ShadowType -> ShowS
    showsPrec :: Int -> ShadowType -> ShowS
    $cshow :: ShadowType -> String
    show :: ShadowType -> String
    $cshowList :: [ShadowType] -> ShowS
    showList :: [ShadowType] -> ShowS
    Show)

    {-# LINE 395 "./Graphics/UI/Gtk/General/Enums.chs" #-}

    -- | Describes a widget state. Widget states are used to match the widget against
    -- CSS pseudo-classes. Note that GTK extends the regular CSS classes and
    -- sometimes uses different names.
    --
    data StateFlags = StateFlagNormal
                    | StateFlagActive
                    | StateFlagPrelight
                    | StateFlagSelected
                    | StateFlagInsensitive
                    | StateFlagInconsistent
                    | StateFlagFocused
                    | StateFlagBackdrop
                    | StateFlagDirLtr
                    | StateFlagDirRtl
                    | StateFlagLink
                    | StateFlagVisited
                    | StateFlagChecked
                    | StateFlagDropActive
                    deriving (Bounded,Eq,Show)
    instance Enum StateFlags where
      fromEnum :: StateFlags -> Int
    fromEnum StateFlags
    StateFlagNormal = Int
    0
      fromEnum StateFlags
    StateFlagActive = Int
    1
      fromEnum StateFlags
    StateFlagPrelight = Int
    2
      fromEnum StateFlags
    StateFlagSelected = Int
    4
      fromEnum StateFlags
    StateFlagInsensitive = Int
    8
      fromEnum StateFlags
    StateFlagInconsistent = Int
    16
      fromEnum StateFlags
    StateFlagFocused = Int
    32
      fromEnum StateFlags
    StateFlagBackdrop = Int
    64
      fromEnum StateFlags
    StateFlagDirLtr = Int
    128
      fromEnum StateFlags
    StateFlagDirRtl = Int
    256
      fromEnum StateFlags
    StateFlagLink = Int
    512
      fromEnum StateFlags
    StateFlagVisited = Int
    1024
      fromEnum StateFlagChecked = 2048
      fromEnum StateFlags
    StateFlagDropActive = Int
    4096

      toEnum 0 = StateFlagNormal
      toEnum 1 = StateFlagActive
      toEnum 2 = StateFlagPrelight
      toEnum 4 = StateFlagSelected
      toEnum 8 = StateFlagInsensitive
      toEnum 16 = StateFlagInconsistent
      toEnum 32 = StateFlagFocused
      toEnum 64 = StateFlagBackdrop
      toEnum 128 = StateFlagDirLtr
      toEnum 256 = StateFlagDirRtl
      toEnum 512 = StateFlagLink
      toEnum 1024 = StateFlagVisited
      toEnum 2048 = StateFlagChecked
      toEnum 4096 = StateFlagDropActive
      toEnum unmatched = error ("StateFlags.toEnum: Cannot match " ++ show unmatched)

      succ StateFlagNormal = StateFlagActive
      succ StateFlagActive = StateFlagPrelight
      succ StateFlagPrelight = StateFlagSelected
      succ StateFlagSelected = StateFlagInsensitive
      succ StateFlagInsensitive = StateFlagInconsistent
      succ StateFlagInconsistent = StateFlagFocused
      succ StateFlagFocused = StateFlagBackdrop
      succ StateFlagBackdrop = StateFlagDirLtr
      succ StateFlagDirLtr = StateFlagDirRtl
      succ StateFlagDirRtl = StateFlagLink
      succ StateFlagLink = StateFlagVisited
      succ StateFlagVisited = StateFlagChecked
      succ StateFlagChecked = StateFlagDropActive
      succ _ = undefined

      pred :: StateFlags -> StateFlags
    pred StateFlagActive = StateFlags
    StateFlagNormal
      pred StateFlagPrelight = StateFlags
    StateFlagActive
      pred StateFlagSelected = StateFlags
    StateFlagPrelight
      pred StateFlags
    StateFlagInsensitive = StateFlags
    StateFlagSelected
      pred StateFlagInconsistent = StateFlags
    StateFlagInsensitive
      pred StateFlagFocused = StateFlags
    StateFlagInconsistent
      pred StateFlagBackdrop = StateFlags
    StateFlagFocused
      pred StateFlags
    StateFlagDirLtr = StateFlags
    StateFlagBackdrop
      pred StateFlags
    StateFlagDirRtl = StateFlags
    StateFlagDirLtr
      succ :: TextSearchFlags -> TextSearchFlags
    pred StateFlags
    StateFlagLink = StateFlags
    StateFlagDirRtl
      pred StateFlags
    StateFlagVisited = StateFlags
    StateFlagLink
      pred StateFlags
    StateFlagChecked = StateFlags
    StateFlagVisited
      pred StateFlags
    StateFlagDropActive = StateFlags
    StateFlagChecked
      pred StateFlags
    _ = StateFlags
    forall a. HasCallStack => a
    undefined

      enumFromTo x y | fromEnum x == fromEnum y = [ y ]
                     | otherwise = x : enumFromTo (succ x) y
      enumFrom :: StateFlags -> [StateFlags]
    enumFrom StateFlags
    x TextSearchFlags
    = StateFlags -> StateFlags -> [StateFlags]
    forall a. Enum a => a -> a -> [a]
    enumFromTo StateFlags
    x StateFlags
    StateFlagDropActive
      enumFromThen _ _ =     error "Enum StateFlags: enumFromThen not implemented"
      enumFromThenTo :: StateFlags -> StateFlags -> StateFlags -> [StateFlags]
    enumFromThenTo StateFlags
    _ StateFlags
    _ StateFlags
    _ =     error String
    "Enum StateFlags: enumFromThenTo not implemented"

    {-# LINE 402 "./Graphics/UI/Gtk/General/Enums.chs" #-}

    instance Flags StateFlags

    -- Sort a 'Graphics.UI.Gtk.ModelView.TreeViewColumn' in ascending or descending
    -- order.
    --
    data SortType = SortAscending
                  | SortDescending
                  deriving (Enum,Eq,Show)

    {-# LINE 410 "./Graphics/UI/Gtk/General/Enums.chs" #-}

    -- | Widget states
    --
    data StateType = StateNormal
                   | StateActive
                   | StatePrelight
                   | StateSelected
                   | StateInsensitive
                   | StateInconsistent
                   | StateFocused
                   deriving (Enum,Eq,Show)

    {-# LINE 429 "./Graphics/UI/Gtk/General/Enums.chs" #-}
    -- | Whether to clamp or ignore illegal values.
    --
    data SpinButtonUpdatePolicy = UpdateAlways
                                | UpdateIfValid
                                deriving (Enum,Eq,Show)

    {-# LINE 432 "./Graphics/UI/Gtk/General/Enums.chs" #-}

    -- | Spin a SpinButton with the following method.
    --
    data SpinType = SpinStepForward
                  | SpinStepBackward
                  | SpinPageForward
                  | SpinPageBackward
                  | SpinHome
                  | SpinEnd
                  | SpinUserDefined
                  deriving (Enum,Eq,Show)

    {-# LINE 436 "./Graphics/UI/Gtk/General/Enums.chs" #-}

    -- | The 'TargetFlags' enumeration is used to specify constraints on an entry
    -- in a 'Graphics.UI.Gtk.Gdk.Selection.TargetList'. These flags are only
    -- used for drag and drop.
    --
    -- * If the 'TargetSameApp' flag is set, the target will only be selected for
    -- drags within a single application.
    --
    -- * If the 'TargetSameWidget' flag is set, the target will only be selected
    -- for drags within a single widget.
    --
    data TargetFlags = TargetSameApp
                     | TargetSameWidget
                     | TargetOtherApp
                     | TargetOtherWidget
                     deriving (Bounded,Eq,Show)
    instance Enum TargetFlags where
      fromEnum TargetSameApp = 1
      fromEnum TargetSameWidget = 2
      fromEnum TargetOtherApp = 4
      fromEnum TargetOtherWidget = 8

      toEnum 1 = TargetSameApp
      toEnum 2 = TargetSameWidget
      toEnum 4 = TargetOtherApp
      toEnum 8 = TargetOtherWidget
      toEnum unmatched = error ("TargetFlags.toEnum: Cannot match " ++ show unmatched)

      succ TargetSameApp = TargetSameWidget
      succ TargetSameWidget = TargetOtherApp
      succ TargetOtherApp = TargetOtherWidget
      succ _ = undefined

      pred TargetSameWidget = TargetSameApp
      pred TargetOtherApp = TargetSameWidget
      pred TargetOtherWidget = TargetOtherApp
      pred _ = undefined

      enumFromTo x y | fromEnum x == fromEnum y = [ y ]
                     | otherwise = x : enumFromTo (succ x) y
      enumFrom x = enumFromTo x TargetOtherWidget
      enumFromThen _ _ =     error "Enum TargetFlags: enumFromThen not implemented"
      enumFromThenTo _ _ _ =     error "Enum TargetFlags: enumFromThenTo not implemented"

    {-# LINE 448 "./Graphics/UI/Gtk/General/Enums.chs" #-}

    instance Flags TargetFlags

    -- | Is the text written from left to right or the exotic way?
    --
    data TextDirection = TextDirNone
                       | TextDirLtr
                       | TextDirRtl
                       deriving (Enum,Eq,Show)

    {-# LINE 454 "./Graphics/UI/Gtk/General/Enums.chs" #-}

    -- | Specify the way the search function for
    -- 'Graphics.UI.Gtk.Multiline.TextBuffer' works.
    --
    data TextSearchFlags = TextSearchVisibleOnly
                         | TextSearchTextOnly
                         | TextSearchCaseInsensitive
                         deriving (Bounded,Eq,Show)
    instance Enum TextSearchFlags where
      fromEnum TextSearchVisibleOnly = 1
      fromEnum TextSearchTextOnly = 2
      fromEnum TextSearchCaseInsensitive = 4

      toEnum 1 = TextSearchVisibleOnly
      toEnum 2 = TextSearchTextOnly
      toEnum 4 = TextSearchCaseInsensitive
      toEnum unmatched = error ("TextSearchFlags.toEnum: Cannot match " ++ show unmatched)

      succ TextSearchVisibleOnly = TextSearchTextOnly
      succ TextSearchTextOnly = TextSearchCaseInsensitive
      succ _ = undefined

      pred TextSearchTextOnly = TextSearchVisibleOnly
      pred TextSearchCaseInsensitive = TextSearchTextOnly
      pred _ = undefined

      enumFromTo x y | fromEnum x == fromEnum y = [ y ]
                     | otherwise = x : enumFromTo (succ x) y
      enumFrom x = enumFromTo x TextSearchCaseInsensitive
      enumFromThen _ _ =     error "Enum TextSearchFlags: enumFromThen not implemented"
      enumFromThenTo _ _ _ =     error "Enum TextSearchFlags: enumFromThenTo not implemented"

    {-# LINE 459 "./Graphics/UI/Gtk/General/Enums.chs" #-}

    instance Flags TextSearchFlags

    -- | The window type for coordinate translation.
    --
    data TextWindowType = TextWindowPrivate
                        | TextWindowWidget
                        | TextWindowText
                        | TextWindowLeft
                        | TextWindowRight
                        | TextWindowTop
                        | TextWindowBottom
                        deriving (Enum,Eq,Show)

    {-# LINE 465 "./Graphics/UI/Gtk/General/Enums.chs" #-}

    -- | Where to place the toolbar?
    --
    data ToolbarStyle = ToolbarIcons
                      | ToolbarText
                      | ToolbarBoth
                      | ToolbarBothHoriz
                      deriving (Enum,Eq,Show)

    {-# LINE 469 "./Graphics/UI/Gtk/General/Enums.chs" #-}

    -- | Whether columns of a tree or list widget can be resized.
    --
    data TreeViewColumnSizing = TreeViewColumnGrowOnly
                              | TreeViewColumnAutosize
                              | TreeViewColumnFixed
                              deriving (Enum,Eq,Show)

    {-# LINE 473 "./Graphics/UI/Gtk/General/Enums.chs" #-}

    -- hm... text editing?
    --{#enum TroughType {underscoreToCase} deriving (Eq,Show)#}
    {-# LINE 490 "./Graphics/UI/Gtk/General/Enums.chs" #-}
    -- | Window position types
    --
    data WindowPosition = WinPosNone
                        | WinPosCenter
                        | WinPosMouse
                        | WinPosCenterAlways
                        | WinPosCenterOnParent
                        deriving (Int -> WindowPosition
    WindowPosition -> Int
    WindowPosition -> [WindowPosition]
    WindowPosition -> WindowPosition
    WindowPosition -> WindowPosition -> [WindowPosition]
    WindowPosition
    -> WindowPosition -> WindowPosition -> [WindowPosition]
    (WindowPosition -> WindowPosition)
    -> (WindowPosition -> WindowPosition)
    -> (Int -> WindowPosition)
    -> (WindowPosition -> Int)
    -> (WindowPosition -> [WindowPosition])
    -> (WindowPosition -> WindowPosition -> [WindowPosition])
    -> (WindowPosition -> WindowPosition -> [WindowPosition])
    -> (WindowPosition
        -> WindowPosition -> WindowPosition -> [WindowPosition])
    -> Enum WindowPosition
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: WindowPosition -> WindowPosition
    succ :: WindowPosition -> WindowPosition
    $cpred :: WindowPosition -> WindowPosition
    pred :: WindowPosition -> WindowPosition
    $ctoEnum :: Int -> WindowPosition
    toEnum :: Int -> WindowPosition
    $cfromEnum :: WindowPosition -> Int
    fromEnum :: WindowPosition -> Int
    $cenumFrom :: WindowPosition -> [WindowPosition]
    enumFrom :: WindowPosition -> [WindowPosition]
    $cenumFromThen :: WindowPosition -> WindowPosition -> [WindowPosition]
    enumFromThen :: WindowPosition -> WindowPosition -> [WindowPosition]
    $cenumFromTo :: WindowPosition -> WindowPosition -> [WindowPosition]
    enumFromTo :: WindowPosition -> WindowPosition -> [WindowPosition]
    $cenumFromThenTo :: WindowPosition
    -> WindowPosition -> WindowPosition -> [WindowPosition]
    enumFromThenTo :: WindowPosition
    -> WindowPosition -> WindowPosition -> [WindowPosition]
    Enum,WindowPosition -> WindowPosition -> Bool
    (WindowPosition -> WindowPosition -> Bool)
    -> (WindowPosition -> WindowPosition -> Bool) -> Eq WindowPosition
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: WindowPosition -> WindowPosition -> Bool
    == :: WindowPosition -> WindowPosition -> Bool
    $c/= :: WindowPosition -> WindowPosition -> Bool
    /= :: WindowPosition -> WindowPosition -> Bool
    Eq,Int -> WindowPosition -> ShowS
    [WindowPosition] -> ShowS
    WindowPosition -> String
    (Int -> WindowPosition -> ShowS)
    -> (WindowPosition -> String)
    -> ([WindowPosition] -> ShowS)
    -> Show WindowPosition
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> WindowPosition -> ShowS
    showsPrec :: Int -> WindowPosition -> ShowS
    $cshow :: WindowPosition -> String
    show :: WindowPosition -> String
    $cshowList :: [WindowPosition] -> ShowS
    showList :: [WindowPosition] -> ShowS
    Show)

    {-# LINE 493 "./Graphics/UI/Gtk/General/Enums.chs" #-}

    -- | Interaction of a window with window manager
    --
    data WindowType = WindowToplevel
                    | WindowPopup
                    deriving (Enum,Eq,Show)

    {-# LINE 497 "./Graphics/UI/Gtk/General/Enums.chs" #-}

    -- | Determine how lines are wrapped in a 'Graphics.UI.Gtk.Multiline.TextView'.
    --
    data WrapMode = WrapNone
                  | WrapChar
                  | WrapWord
                  | WrapWordChar
                  deriving (Enum,Eq,Show)

    {-# LINE 501 "./Graphics/UI/Gtk/General/Enums.chs" #-}

    -- | Specifies the side of the entry at which an icon is placed.
    --
    data EntryIconPosition = EntryIconPrimary
                           | EntryIconSecondary
                           deriving (Enum,Eq,Show)

    {-# LINE 516 "./Graphics/UI/Gtk/General/Enums.chs" #-}
    data StackTransitionType = StackTransitionTypeNone
                             | StackTransitionTypeCrossfade
                             | StackTransitionTypeSlideRight
                             | StackTransitionTypeSlideLeft
                             | StackTransitionTypeSlideUp
                             | StackTransitionTypeSlideDown
                             | StackTransitionTypeSlideLeftRight
                             | StackTransitionTypeSlideUpDown
                             | StackTransitionTypeOverUp
                             | StackTransitionTypeOverDown
                             | StackTransitionTypeOverLeft
                             | StackTransitionTypeOverRight
                             | StackTransitionTypeUnderUp
                             | StackTransitionTypeUnderDown
                             | StackTransitionTypeUnderLeft
                             | StackTransitionTypeUnderRight
                             | StackTransitionTypeOverUpDown
                             | StackTransitionTypeOverDownUp
                             | StackTransitionTypeOverLeftRight
                             | StackTransitionTypeOverRightLeft
                             deriving (Int -> StackTransitionType
    StackTransitionType -> Int
    StackTransitionType -> [StackTransitionType]
    StackTransitionType -> StackTransitionType
    StackTransitionType -> StackTransitionType -> [StackTransitionType]
    StackTransitionType
    -> StackTransitionType
    -> StackTransitionType
    -> [StackTransitionType]
    (StackTransitionType -> StackTransitionType)
    -> (StackTransitionType -> StackTransitionType)
    -> (Int -> StackTransitionType)
    -> (StackTransitionType -> Int)
    -> (StackTransitionType -> [StackTransitionType])
    -> (StackTransitionType
        -> StackTransitionType -> [StackTransitionType])
    -> (StackTransitionType
        -> StackTransitionType -> [StackTransitionType])
    -> (StackTransitionType
        -> StackTransitionType
        -> StackTransitionType
        -> [StackTransitionType])
    -> Enum StackTransitionType
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: StackTransitionType -> StackTransitionType
    succ :: StackTransitionType -> StackTransitionType
    $cpred :: StackTransitionType -> StackTransitionType
    pred :: StackTransitionType -> StackTransitionType
    $ctoEnum :: Int -> StackTransitionType
    toEnum :: Int -> StackTransitionType
    $cfromEnum :: StackTransitionType -> Int
    fromEnum :: StackTransitionType -> Int
    $cenumFrom :: StackTransitionType -> [StackTransitionType]
    enumFrom :: StackTransitionType -> [StackTransitionType]
    $cenumFromThen :: StackTransitionType -> StackTransitionType -> [StackTransitionType]
    enumFromThen :: StackTransitionType -> StackTransitionType -> [StackTransitionType]
    $cenumFromTo :: StackTransitionType -> StackTransitionType -> [StackTransitionType]
    enumFromTo :: StackTransitionType -> StackTransitionType -> [StackTransitionType]
    $cenumFromThenTo :: StackTransitionType
    -> StackTransitionType
    -> StackTransitionType
    -> [StackTransitionType]
    enumFromThenTo :: StackTransitionType
    -> StackTransitionType
    -> StackTransitionType
    -> [StackTransitionType]
    Enum,StackTransitionType -> StackTransitionType -> Bool
    (StackTransitionType -> StackTransitionType -> Bool)
    -> (StackTransitionType -> StackTransitionType -> Bool)
    -> Eq StackTransitionType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: StackTransitionType -> StackTransitionType -> Bool
    == :: StackTransitionType -> StackTransitionType -> Bool
    $c/= :: StackTransitionType -> StackTransitionType -> Bool
    /= :: StackTransitionType -> StackTransitionType -> Bool
    Eq,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
    $cshowsPrec :: Int -> StackTransitionType -> ShowS
    showsPrec :: Int -> StackTransitionType -> ShowS
    $cshow :: StackTransitionType -> String
    show :: StackTransitionType -> String
    $cshowList :: [StackTransitionType] -> ShowS
    showList :: [StackTransitionType] -> ShowS
    Show)

    {-# LINE 517 "./Graphics/UI/Gtk/General/Enums.chs" #-}