{-# 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 :: AccelFlags -> Int
fromEnum AccelFlags
AccelVisible = Int
1
  fromEnum AccelFlags
AccelLocked = Int
2
  fromEnum AccelFlags
AccelMask = Int
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 Expand = Shrink
  succ Shrink = Fill
  succ _ = undefined

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

  enumFromTo :: AttachOptions -> AttachOptions -> [AttachOptions]
enumFromTo AttachOptions
x AttachOptions
y | AttachOptions -> Int
forall a. Enum a => a -> Int
fromEnum AttachOptions
x Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== AttachOptions -> Int
forall a. Enum a => a -> Int
fromEnum AttachOptions
y = [ AttachOptions
y ]
                 | Bool
otherwise = AttachOptions
x AttachOptions -> [AttachOptions] -> [AttachOptions]
forall a. a -> [a] -> [a]
: AttachOptions -> AttachOptions -> [AttachOptions]
forall a. Enum a => a -> a -> [a]
enumFromTo (AttachOptions -> AttachOptions
forall a. Enum a => a -> a
succ AttachOptions
x) AttachOptions
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 verical 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 availible 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
_ =     String -> [DestDefaults]
forall a. HasCallStack => String -> a
error String
"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
-- trough
--
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 StateFlags
StateFlagPrelight = StateFlags
StateFlagActive
  pred StateFlagSelected = StateFlags
StateFlagPrelight
  pred StateFlags
StateFlagInsensitive = StateFlags
StateFlagSelected
  pred StateFlagInconsistent = StateFlags
StateFlagInsensitive
  pred StateFlags
StateFlagFocused = StateFlags
StateFlagInconsistent
  pred StateFlags
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" #-}

-- | Wether 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" #-}