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



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



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

  DragResult(..),

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





  MatchType(..),


  MenuDirectionType(..),


  MetricType(..),


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

  ProgressBarOrientation(..),

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



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


  SubmenuDirection(..),
  SubmenuPlacement(..),


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

  UpdateType(..),
  Visibility(..),

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

  EntryIconPosition(..),


  AnchorType (..),





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 :: AccelFlags -> AccelFlags
succ AccelFlags
AccelVisible = AccelFlags
AccelLocked
  succ AccelFlags
AccelLocked = AccelFlags
AccelMask
  succ AccelFlags
_ = AccelFlags
forall a. HasCallStack => a
undefined

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

  enumFromTo :: AccelFlags -> AccelFlags -> [AccelFlags]
enumFromTo AccelFlags
x AccelFlags
y | AccelFlags -> Int
forall a. Enum a => a -> Int
fromEnum AccelFlags
x Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== AccelFlags -> Int
forall a. Enum a => a -> Int
fromEnum AccelFlags
y = [ AccelFlags
y ]
                 | Bool
otherwise = AccelFlags
x AccelFlags -> [AccelFlags] -> [AccelFlags]
forall a. a -> [a] -> [a]
: AccelFlags -> AccelFlags -> [AccelFlags]
forall a. Enum a => a -> a -> [a]
enumFromTo (AccelFlags -> AccelFlags
forall a. Enum a => a -> a
succ AccelFlags
x) AccelFlags
y
  enumFrom :: AccelFlags -> [AccelFlags]
enumFrom AccelFlags
x = AccelFlags -> AccelFlags -> [AccelFlags]
forall a. Enum a => a -> a -> [a]
enumFromTo AccelFlags
x AccelFlags
AccelMask
  enumFromThen :: AccelFlags -> AccelFlags -> [AccelFlags]
enumFromThen AccelFlags
_ AccelFlags
_ =     String -> [AccelFlags]
forall a. HasCallStack => String -> a
error String
"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







-- | 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 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
{-# LINE 159 "./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 = ButtonboxDefaultStyle
                    | ButtonboxSpread
                    | ButtonboxEdge
                    | ButtonboxStart
                    | ButtonboxEnd
                    | ButtonboxCenter
                    deriving (Enum,Eq,Int -> ButtonBoxStyle -> ShowS
[ButtonBoxStyle] -> ShowS
ButtonBoxStyle -> String
(Int -> ButtonBoxStyle -> ShowS)
-> (ButtonBoxStyle -> String)
-> ([ButtonBoxStyle] -> ShowS)
-> Show ButtonBoxStyle
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ButtonBoxStyle -> ShowS
showsPrec :: Int -> ButtonBoxStyle -> ShowS
$cshow :: ButtonBoxStyle -> String
show :: ButtonBoxStyle -> String
$cshowList :: [ButtonBoxStyle] -> ShowS
showList :: [ButtonBoxStyle] -> ShowS
Show)

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

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

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

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

  pred CalendarShowDayNames = CalendarShowHeading
  pred CalendarNoMonthChange = CalendarShowDayNames
  pred CalendarShowWeekNumbers = CalendarNoMonthChange
  pred CalendarWeekStartMonday = CalendarShowWeekNumbers
  pred CalendarShowDetails = CalendarWeekStartMonday
  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 (Bounded,Eq,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 (Int -> Justification
Justification -> Int
Justification -> [Justification]
Justification -> Justification
Justification -> Justification -> [Justification]
Justification -> Justification -> Justification -> [Justification]
(Justification -> Justification)
-> (Justification -> Justification)
-> (Int -> Justification)
-> (Justification -> Int)
-> (Justification -> [Justification])
-> (Justification -> Justification -> [Justification])
-> (Justification -> Justification -> [Justification])
-> (Justification
    -> Justification -> Justification -> [Justification])
-> Enum Justification
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 :: Justification -> Justification
succ :: Justification -> Justification
$cpred :: Justification -> Justification
pred :: Justification -> Justification
$ctoEnum :: Int -> Justification
toEnum :: Int -> Justification
$cfromEnum :: Justification -> Int
fromEnum :: Justification -> Int
$cenumFrom :: Justification -> [Justification]
enumFrom :: Justification -> [Justification]
$cenumFromThen :: Justification -> Justification -> [Justification]
enumFromThen :: Justification -> Justification -> [Justification]
$cenumFromTo :: Justification -> Justification -> [Justification]
enumFromTo :: Justification -> Justification -> [Justification]
$cenumFromThenTo :: Justification -> Justification -> Justification -> [Justification]
enumFromThenTo :: Justification -> Justification -> Justification -> [Justification]
Enum,Justification -> Justification -> Bool
(Justification -> Justification -> Bool)
-> (Justification -> Justification -> Bool) -> Eq Justification
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Justification -> Justification -> Bool
== :: Justification -> Justification -> Bool
$c/= :: Justification -> Justification -> Bool
/= :: Justification -> Justification -> Bool
Eq,Int -> Justification -> ShowS
[Justification] -> ShowS
Justification -> String
(Int -> Justification -> ShowS)
-> (Justification -> String)
-> ([Justification] -> ShowS)
-> Show Justification
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Justification -> ShowS
showsPrec :: Int -> Justification -> ShowS
$cshow :: Justification -> String
show :: Justification -> String
$cshowList :: [Justification] -> ShowS
showList :: [Justification] -> ShowS
Show)

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







-- | Some kind of string search options
--
-- Removed in Gtk3.
data MatchType = MatchAll
               | MatchAllTail
               | MatchHead
               | MatchTail
               | MatchExact
               | MatchLast
               deriving (Int -> MatchType
MatchType -> Int
MatchType -> [MatchType]
MatchType -> MatchType
MatchType -> MatchType -> [MatchType]
MatchType -> MatchType -> MatchType -> [MatchType]
(MatchType -> MatchType)
-> (MatchType -> MatchType)
-> (Int -> MatchType)
-> (MatchType -> Int)
-> (MatchType -> [MatchType])
-> (MatchType -> MatchType -> [MatchType])
-> (MatchType -> MatchType -> [MatchType])
-> (MatchType -> MatchType -> MatchType -> [MatchType])
-> Enum MatchType
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 :: MatchType -> MatchType
succ :: MatchType -> MatchType
$cpred :: MatchType -> MatchType
pred :: MatchType -> MatchType
$ctoEnum :: Int -> MatchType
toEnum :: Int -> MatchType
$cfromEnum :: MatchType -> Int
fromEnum :: MatchType -> Int
$cenumFrom :: MatchType -> [MatchType]
enumFrom :: MatchType -> [MatchType]
$cenumFromThen :: MatchType -> MatchType -> [MatchType]
enumFromThen :: MatchType -> MatchType -> [MatchType]
$cenumFromTo :: MatchType -> MatchType -> [MatchType]
enumFromTo :: MatchType -> MatchType -> [MatchType]
$cenumFromThenTo :: MatchType -> MatchType -> MatchType -> [MatchType]
enumFromThenTo :: MatchType -> MatchType -> MatchType -> [MatchType]
Enum,MatchType -> MatchType -> Bool
(MatchType -> MatchType -> Bool)
-> (MatchType -> MatchType -> Bool) -> Eq MatchType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MatchType -> MatchType -> Bool
== :: MatchType -> MatchType -> Bool
$c/= :: MatchType -> MatchType -> Bool
/= :: MatchType -> MatchType -> Bool
Eq,Int -> MatchType -> ShowS
[MatchType] -> ShowS
MatchType -> String
(Int -> MatchType -> ShowS)
-> (MatchType -> String)
-> ([MatchType] -> ShowS)
-> Show MatchType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MatchType -> ShowS
showsPrec :: Int -> MatchType -> ShowS
$cshow :: MatchType -> String
show :: MatchType -> String
$cshowList :: [MatchType] -> ShowS
showList :: [MatchType] -> ShowS
Show)

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



-- | From where was a menu item entered?
--
data MenuDirectionType = MenuDirParent
                       | MenuDirChild
                       | MenuDirNext
                       | MenuDirPrev
                       deriving (Enum,Eq,Show)

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


-- | Units of measure
--
-- Removed in Gtk3.
data MetricType = Pixels
                | Inches
                | Centimeters
                deriving (Enum,Eq,Show)

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


-- | Movement in text widget
--
data MovementStep = MovementLogicalPositions
                  | MovementVisualPositions
                  | MovementWords
                  | MovementDisplayLines
                  | MovementDisplayLineEnds
                  | MovementParagraphs
                  | MovementParagraphEnds
                  | MovementPages
                  | MovementBufferEnds
                  | MovementHorizontalPages
                  deriving (Enum,Eq,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 :: PathPriorityType -> PathPriorityType
succ PathPriorityType
PathPrioLowest = PathPriorityType
PathPrioGtk
  succ PathPriorityType
PathPrioGtk = PathPriorityType
PathPrioApplication
  succ PathPriorityType
PathPrioApplication = PathPriorityType
PathPrioTheme
  succ PathPriorityType
PathPrioTheme = PathPriorityType
PathPrioRc
  succ PathPriorityType
PathPrioRc = PathPriorityType
PathPrioHighest
  succ PathPriorityType
_ = PathPriorityType
forall a. HasCallStack => a
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
                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 349 "./Graphics/UI/Gtk/General/Enums.chs" #-}


-- | Is the ProgressBar horizontally or vertically
-- directed?
--
-- Removed in Gtk3.
data ProgressBarOrientation = ProgressLeftToRight
                            | ProgressRightToLeft
                            | ProgressBottomToTop
                            | ProgressTopToBottom
                            deriving (Enum,Eq,Show)

{-# LINE 356 "./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 406 "./Graphics/UI/Gtk/General/Enums.chs" #-}
-- Sort a 'Graphics.UI.Gtk.ModelView.TreeViewColumn' in ascending or descending
-- order.
--
data SortType = SortAscending
              | SortDescending
              deriving (Int -> SortType
SortType -> Int
SortType -> [SortType]
SortType -> SortType
SortType -> SortType -> [SortType]
SortType -> SortType -> SortType -> [SortType]
(SortType -> SortType)
-> (SortType -> SortType)
-> (Int -> SortType)
-> (SortType -> Int)
-> (SortType -> [SortType])
-> (SortType -> SortType -> [SortType])
-> (SortType -> SortType -> [SortType])
-> (SortType -> SortType -> SortType -> [SortType])
-> Enum SortType
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 :: SortType -> SortType
succ :: SortType -> SortType
$cpred :: SortType -> SortType
pred :: SortType -> SortType
$ctoEnum :: Int -> SortType
toEnum :: Int -> SortType
$cfromEnum :: SortType -> Int
fromEnum :: SortType -> Int
$cenumFrom :: SortType -> [SortType]
enumFrom :: SortType -> [SortType]
$cenumFromThen :: SortType -> SortType -> [SortType]
enumFromThen :: SortType -> SortType -> [SortType]
$cenumFromTo :: SortType -> SortType -> [SortType]
enumFromTo :: SortType -> SortType -> [SortType]
$cenumFromThenTo :: SortType -> SortType -> SortType -> [SortType]
enumFromThenTo :: SortType -> SortType -> SortType -> [SortType]
Enum,SortType -> SortType -> Bool
(SortType -> SortType -> Bool)
-> (SortType -> SortType -> Bool) -> Eq SortType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SortType -> SortType -> Bool
== :: SortType -> SortType -> Bool
$c/= :: SortType -> SortType -> Bool
/= :: SortType -> SortType -> Bool
Eq,Int -> SortType -> ShowS
[SortType] -> ShowS
SortType -> String
(Int -> SortType -> ShowS)
-> (SortType -> String) -> ([SortType] -> ShowS) -> Show SortType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SortType -> ShowS
showsPrec :: Int -> SortType -> ShowS
$cshow :: SortType -> String
show :: SortType -> String
$cshowList :: [SortType] -> ShowS
showList :: [SortType] -> ShowS
Show)

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

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

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



-- | Submenu direction policies
--
-- Removed in Gtk3.
data SubmenuDirection = DirectionLeft
                      | DirectionRight
                      deriving (Enum,Eq,Show)

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

-- | Submenu placement policies
--
-- Removed in Gtk3.
data SubmenuPlacement = TopBottom
                      | LeftRight
                      deriving (Int -> SubmenuPlacement
SubmenuPlacement -> Int
SubmenuPlacement -> [SubmenuPlacement]
SubmenuPlacement -> SubmenuPlacement
SubmenuPlacement -> SubmenuPlacement -> [SubmenuPlacement]
SubmenuPlacement
-> SubmenuPlacement -> SubmenuPlacement -> [SubmenuPlacement]
(SubmenuPlacement -> SubmenuPlacement)
-> (SubmenuPlacement -> SubmenuPlacement)
-> (Int -> SubmenuPlacement)
-> (SubmenuPlacement -> Int)
-> (SubmenuPlacement -> [SubmenuPlacement])
-> (SubmenuPlacement -> SubmenuPlacement -> [SubmenuPlacement])
-> (SubmenuPlacement -> SubmenuPlacement -> [SubmenuPlacement])
-> (SubmenuPlacement
    -> SubmenuPlacement -> SubmenuPlacement -> [SubmenuPlacement])
-> Enum SubmenuPlacement
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 :: SubmenuPlacement -> SubmenuPlacement
succ :: SubmenuPlacement -> SubmenuPlacement
$cpred :: SubmenuPlacement -> SubmenuPlacement
pred :: SubmenuPlacement -> SubmenuPlacement
$ctoEnum :: Int -> SubmenuPlacement
toEnum :: Int -> SubmenuPlacement
$cfromEnum :: SubmenuPlacement -> Int
fromEnum :: SubmenuPlacement -> Int
$cenumFrom :: SubmenuPlacement -> [SubmenuPlacement]
enumFrom :: SubmenuPlacement -> [SubmenuPlacement]
$cenumFromThen :: SubmenuPlacement -> SubmenuPlacement -> [SubmenuPlacement]
enumFromThen :: SubmenuPlacement -> SubmenuPlacement -> [SubmenuPlacement]
$cenumFromTo :: SubmenuPlacement -> SubmenuPlacement -> [SubmenuPlacement]
enumFromTo :: SubmenuPlacement -> SubmenuPlacement -> [SubmenuPlacement]
$cenumFromThenTo :: SubmenuPlacement
-> SubmenuPlacement -> SubmenuPlacement -> [SubmenuPlacement]
enumFromThenTo :: SubmenuPlacement
-> SubmenuPlacement -> SubmenuPlacement -> [SubmenuPlacement]
Enum,SubmenuPlacement -> SubmenuPlacement -> Bool
(SubmenuPlacement -> SubmenuPlacement -> Bool)
-> (SubmenuPlacement -> SubmenuPlacement -> Bool)
-> Eq SubmenuPlacement
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SubmenuPlacement -> SubmenuPlacement -> Bool
== :: SubmenuPlacement -> SubmenuPlacement -> Bool
$c/= :: SubmenuPlacement -> SubmenuPlacement -> Bool
/= :: SubmenuPlacement -> SubmenuPlacement -> Bool
Eq,Int -> SubmenuPlacement -> ShowS
[SubmenuPlacement] -> ShowS
SubmenuPlacement -> String
(Int -> SubmenuPlacement -> ShowS)
-> (SubmenuPlacement -> String)
-> ([SubmenuPlacement] -> ShowS)
-> Show SubmenuPlacement
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SubmenuPlacement -> ShowS
showsPrec :: Int -> SubmenuPlacement -> ShowS
$cshow :: SubmenuPlacement -> String
show :: SubmenuPlacement -> String
$cshowList :: [SubmenuPlacement] -> ShowS
showList :: [SubmenuPlacement] -> ShowS
Show)

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



-- | Whether to clamp or ignore illegal values.
--
data SpinButtonUpdatePolicy = UpdateAlways
                            | UpdateIfValid
                            deriving (Int -> SpinButtonUpdatePolicy
SpinButtonUpdatePolicy -> Int
SpinButtonUpdatePolicy -> [SpinButtonUpdatePolicy]
SpinButtonUpdatePolicy -> SpinButtonUpdatePolicy
SpinButtonUpdatePolicy
-> SpinButtonUpdatePolicy -> [SpinButtonUpdatePolicy]
SpinButtonUpdatePolicy
-> SpinButtonUpdatePolicy
-> SpinButtonUpdatePolicy
-> [SpinButtonUpdatePolicy]
(SpinButtonUpdatePolicy -> SpinButtonUpdatePolicy)
-> (SpinButtonUpdatePolicy -> SpinButtonUpdatePolicy)
-> (Int -> SpinButtonUpdatePolicy)
-> (SpinButtonUpdatePolicy -> Int)
-> (SpinButtonUpdatePolicy -> [SpinButtonUpdatePolicy])
-> (SpinButtonUpdatePolicy
    -> SpinButtonUpdatePolicy -> [SpinButtonUpdatePolicy])
-> (SpinButtonUpdatePolicy
    -> SpinButtonUpdatePolicy -> [SpinButtonUpdatePolicy])
-> (SpinButtonUpdatePolicy
    -> SpinButtonUpdatePolicy
    -> SpinButtonUpdatePolicy
    -> [SpinButtonUpdatePolicy])
-> Enum SpinButtonUpdatePolicy
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 :: SpinButtonUpdatePolicy -> SpinButtonUpdatePolicy
succ :: SpinButtonUpdatePolicy -> SpinButtonUpdatePolicy
$cpred :: SpinButtonUpdatePolicy -> SpinButtonUpdatePolicy
pred :: SpinButtonUpdatePolicy -> SpinButtonUpdatePolicy
$ctoEnum :: Int -> SpinButtonUpdatePolicy
toEnum :: Int -> SpinButtonUpdatePolicy
$cfromEnum :: SpinButtonUpdatePolicy -> Int
fromEnum :: SpinButtonUpdatePolicy -> Int
$cenumFrom :: SpinButtonUpdatePolicy -> [SpinButtonUpdatePolicy]
enumFrom :: SpinButtonUpdatePolicy -> [SpinButtonUpdatePolicy]
$cenumFromThen :: SpinButtonUpdatePolicy
-> SpinButtonUpdatePolicy -> [SpinButtonUpdatePolicy]
enumFromThen :: SpinButtonUpdatePolicy
-> SpinButtonUpdatePolicy -> [SpinButtonUpdatePolicy]
$cenumFromTo :: SpinButtonUpdatePolicy
-> SpinButtonUpdatePolicy -> [SpinButtonUpdatePolicy]
enumFromTo :: SpinButtonUpdatePolicy
-> SpinButtonUpdatePolicy -> [SpinButtonUpdatePolicy]
$cenumFromThenTo :: SpinButtonUpdatePolicy
-> SpinButtonUpdatePolicy
-> SpinButtonUpdatePolicy
-> [SpinButtonUpdatePolicy]
enumFromThenTo :: SpinButtonUpdatePolicy
-> SpinButtonUpdatePolicy
-> SpinButtonUpdatePolicy
-> [SpinButtonUpdatePolicy]
Enum,SpinButtonUpdatePolicy -> SpinButtonUpdatePolicy -> Bool
(SpinButtonUpdatePolicy -> SpinButtonUpdatePolicy -> Bool)
-> (SpinButtonUpdatePolicy -> SpinButtonUpdatePolicy -> Bool)
-> Eq SpinButtonUpdatePolicy
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SpinButtonUpdatePolicy -> SpinButtonUpdatePolicy -> Bool
== :: SpinButtonUpdatePolicy -> SpinButtonUpdatePolicy -> Bool
$c/= :: SpinButtonUpdatePolicy -> SpinButtonUpdatePolicy -> Bool
/= :: SpinButtonUpdatePolicy -> SpinButtonUpdatePolicy -> Bool
Eq,Int -> SpinButtonUpdatePolicy -> ShowS
[SpinButtonUpdatePolicy] -> ShowS
SpinButtonUpdatePolicy -> String
(Int -> SpinButtonUpdatePolicy -> ShowS)
-> (SpinButtonUpdatePolicy -> String)
-> ([SpinButtonUpdatePolicy] -> ShowS)
-> Show SpinButtonUpdatePolicy
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SpinButtonUpdatePolicy -> ShowS
showsPrec :: Int -> SpinButtonUpdatePolicy -> ShowS
$cshow :: SpinButtonUpdatePolicy -> String
show :: SpinButtonUpdatePolicy -> String
$cshowList :: [SpinButtonUpdatePolicy] -> ShowS
showList :: [SpinButtonUpdatePolicy] -> ShowS
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 (TargetFlags
TargetFlags -> TargetFlags -> Bounded TargetFlags
forall a. a -> a -> Bounded a
$cminBound :: TargetFlags
minBound :: TargetFlags
$cmaxBound :: TargetFlags
maxBound :: TargetFlags
Bounded,TargetFlags -> TargetFlags -> Bool
(TargetFlags -> TargetFlags -> Bool)
-> (TargetFlags -> TargetFlags -> Bool) -> Eq TargetFlags
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TargetFlags -> TargetFlags -> Bool
== :: TargetFlags -> TargetFlags -> Bool
$c/= :: TargetFlags -> TargetFlags -> Bool
/= :: TargetFlags -> TargetFlags -> Bool
Eq,Int -> TargetFlags -> ShowS
[TargetFlags] -> ShowS
TargetFlags -> String
(Int -> TargetFlags -> ShowS)
-> (TargetFlags -> String)
-> ([TargetFlags] -> ShowS)
-> Show TargetFlags
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TargetFlags -> ShowS
showsPrec :: Int -> TargetFlags -> ShowS
$cshow :: TargetFlags -> String
show :: TargetFlags -> String
$cshowList :: [TargetFlags] -> ShowS
showList :: [TargetFlags] -> ShowS
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 :: TargetFlags -> TargetFlags
succ TargetFlags
TargetSameApp = TargetFlags
TargetSameWidget
  succ TargetFlags
TargetSameWidget = TargetFlags
TargetOtherApp
  succ TargetOtherApp = TargetOtherWidget
  succ TargetFlags
_ = TargetFlags
forall a. HasCallStack => a
undefined

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

  enumFromTo :: TargetFlags -> TargetFlags -> [TargetFlags]
enumFromTo TargetFlags
x TargetFlags
y | TargetFlags -> Int
forall a. Enum a => a -> Int
fromEnum TargetFlags
x Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== TargetFlags -> Int
forall a. Enum a => a -> Int
fromEnum TargetFlags
y = [ TargetFlags
y ]
                 | Bool
otherwise = TargetFlags
x TargetFlags -> [TargetFlags] -> [TargetFlags]
forall a. a -> [a] -> [a]
: TargetFlags -> TargetFlags -> [TargetFlags]
forall a. Enum a => a -> a -> [a]
enumFromTo (TargetFlags -> TargetFlags
forall a. Enum a => a -> a
succ TargetFlags
x) TargetFlags
y
  enumFrom x = enumFromTo x TargetOtherWidget
  enumFromThen :: TargetFlags -> TargetFlags -> [TargetFlags]
enumFromThen TargetFlags
_ TargetFlags
_ =     error String
"Enum TargetFlags: enumFromThen not implemented"
  enumFromThenTo :: TargetFlags -> TargetFlags -> TargetFlags -> [TargetFlags]
enumFromThenTo TextSearchFlags
TargetFlags
_ TargetFlags
_ TargetFlags
_ =     error String
"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
                     deriving (Bounded,Eq,Show)
instance Enum TextSearchFlags where
  fromEnum TextSearchVisibleOnly = 1
  fromEnum TextSearchTextOnly = 2

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

  succ TextSearchVisibleOnly = TextSearchTextOnly
  succ _ = undefined

  pred TextSearchTextOnly = TextSearchVisibleOnly
  pred _ = undefined

  enumFromTo x y | fromEnum x == fromEnum y = [ y ]
                 | otherwise = x : enumFromTo (succ x) y
  enumFrom x = enumFromTo x TextSearchTextOnly
  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)#}


-- | Updating types for range widgets (determines when the
-- @\"connectToValueChanged\"@ signal is emitted by the widget)
--
-- Removed in Gtk3.
data UpdateType = UpdateContinuous
                | UpdateDiscontinuous
                | UpdateDelayed
                deriving (Int -> UpdateType
UpdateType -> Int
UpdateType -> [UpdateType]
UpdateType -> UpdateType
UpdateType -> UpdateType -> [UpdateType]
UpdateType -> UpdateType -> UpdateType -> [UpdateType]
(UpdateType -> UpdateType)
-> (UpdateType -> UpdateType)
-> (Int -> UpdateType)
-> (UpdateType -> Int)
-> (UpdateType -> [UpdateType])
-> (UpdateType -> UpdateType -> [UpdateType])
-> (UpdateType -> UpdateType -> [UpdateType])
-> (UpdateType -> UpdateType -> UpdateType -> [UpdateType])
-> Enum UpdateType
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 :: UpdateType -> UpdateType
succ :: UpdateType -> UpdateType
$cpred :: UpdateType -> UpdateType
pred :: UpdateType -> UpdateType
$ctoEnum :: Int -> UpdateType
toEnum :: Int -> UpdateType
$cfromEnum :: UpdateType -> Int
fromEnum :: UpdateType -> Int
$cenumFrom :: UpdateType -> [UpdateType]
enumFrom :: UpdateType -> [UpdateType]
$cenumFromThen :: UpdateType -> UpdateType -> [UpdateType]
enumFromThen :: UpdateType -> UpdateType -> [UpdateType]
$cenumFromTo :: UpdateType -> UpdateType -> [UpdateType]
enumFromTo :: UpdateType -> UpdateType -> [UpdateType]
$cenumFromThenTo :: UpdateType -> UpdateType -> UpdateType -> [UpdateType]
enumFromThenTo :: UpdateType -> UpdateType -> UpdateType -> [UpdateType]
Enum,UpdateType -> UpdateType -> Bool
(UpdateType -> UpdateType -> Bool)
-> (UpdateType -> UpdateType -> Bool) -> Eq UpdateType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: UpdateType -> UpdateType -> Bool
== :: UpdateType -> UpdateType -> Bool
$c/= :: UpdateType -> UpdateType -> Bool
/= :: UpdateType -> UpdateType -> Bool
Eq,Int -> UpdateType -> ShowS
[UpdateType] -> ShowS
UpdateType -> String
(Int -> UpdateType -> ShowS)
-> (UpdateType -> String)
-> ([UpdateType] -> ShowS)
-> Show UpdateType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> UpdateType -> ShowS
showsPrec :: Int -> UpdateType -> ShowS
$cshow :: UpdateType -> String
show :: UpdateType -> String
$cshowList :: [UpdateType] -> ShowS
showList :: [UpdateType] -> ShowS
Show)

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

-- | Visibility
--
-- Removed in Gtk3.
data Visibility = VisibilityNone
                | VisibilityPartial
                | VisibilityFull
                deriving (Enum,Eq,Show)

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


-- | Window position types
--
data WindowPosition = WinPosNone
                    | WinPosCenter
                    | WinPosMouse
                    | WinPosCenterAlways
                    | WinPosCenterOnParent
                    deriving (Enum,Eq,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 506 "./Graphics/UI/Gtk/General/Enums.chs" #-}



-- |
--
-- Removed in Gtk3.
data AnchorType = AnchorCenter
                | AnchorNorth
                | AnchorNorthWest
                | AnchorNorthEast
                | AnchorSouth
                | AnchorSouthWest
                | AnchorSouthEast
                | AnchorWest
                | AnchorEast
                | AnchorN
                | AnchorNw
                | AnchorNe
                | AnchorS
                | AnchorSw
                | AnchorSe
                | AnchorW
                | AnchorE
                deriving (AnchorType -> AnchorType -> Bool
(AnchorType -> AnchorType -> Bool)
-> (AnchorType -> AnchorType -> Bool) -> Eq AnchorType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AnchorType -> AnchorType -> Bool
== :: AnchorType -> AnchorType -> Bool
$c/= :: AnchorType -> AnchorType -> Bool
/= :: AnchorType -> AnchorType -> Bool
Eq,Int -> AnchorType -> ShowS
[AnchorType] -> ShowS
AnchorType -> String
(Int -> AnchorType -> ShowS)
-> (AnchorType -> String)
-> ([AnchorType] -> ShowS)
-> Show AnchorType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> AnchorType -> ShowS
showsPrec :: Int -> AnchorType -> ShowS
$cshow :: AnchorType -> String
show :: AnchorType -> String
$cshowList :: [AnchorType] -> ShowS
showList :: [AnchorType] -> ShowS
Show)
instance Enum AnchorType where
  fromEnum :: AnchorType -> Int
fromEnum AnchorType
AnchorCenter = Int
0
  fromEnum AnchorType
AnchorNorth = Int
1
  fromEnum AnchorType
AnchorNorthWest = Int
2
  fromEnum AnchorType
AnchorNorthEast = Int
3
  fromEnum AnchorType
AnchorSouth = Int
4
  fromEnum AnchorType
AnchorSouthWest = Int
5
  fromEnum AnchorType
AnchorSouthEast = Int
6
  fromEnum AnchorType
AnchorWest = Int
7
  fromEnum AnchorType
AnchorEast = Int
8
  fromEnum AnchorType
AnchorN = Int
1
  fromEnum AnchorType
AnchorNw = Int
2
  fromEnum AnchorType
AnchorNe = Int
3
  fromEnum AnchorType
AnchorS = Int
4
  fromEnum AnchorType
AnchorSw = Int
5
  fromEnum AnchorType
AnchorSe = Int
6
  fromEnum AnchorType
AnchorW = Int
7
  fromEnum AnchorType
AnchorE = Int
8

  toEnum :: Int -> AnchorType
toEnum Int
0 = AnchorType
AnchorCenter
  toEnum Int
1 = AnchorType
AnchorNorth
  toEnum Int
2 = AnchorType
AnchorNorthWest
  toEnum Int
3 = AnchorType
AnchorNorthEast
  toEnum Int
4 = AnchorType
AnchorSouth
  toEnum Int
5 = AnchorType
AnchorSouthWest
  toEnum Int
6 = AnchorType
AnchorSouthEast
  toEnum Int
7 = AnchorType
AnchorWest
  toEnum Int
8 = AnchorType
AnchorEast
  toEnum Int
unmatched = String -> AnchorType
forall a. HasCallStack => String -> a
error (String
"AnchorType.toEnum: Cannot match " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Int -> String
forall a. Show a => a -> String
show Int
unmatched)

  succ :: AnchorType -> AnchorType
succ AnchorType
AnchorCenter = AnchorType
AnchorNorth
  succ AnchorType
AnchorNorth = AnchorType
AnchorNorthWest
  succ AnchorType
AnchorNorthWest = AnchorType
AnchorNorthEast
  succ AnchorType
AnchorNorthEast = AnchorType
AnchorSouth
  succ AnchorType
AnchorSouth = AnchorType
AnchorSouthWest
  succ AnchorType
AnchorSouthWest = AnchorType
AnchorSouthEast
  succ AnchorType
AnchorSouthEast = AnchorType
AnchorWest
  succ AnchorType
AnchorWest = AnchorType
AnchorEast
  succ AnchorType
AnchorEast = AnchorType
AnchorN
  succ AnchorType
AnchorN = AnchorType
AnchorNw
  succ AnchorType
AnchorNw = AnchorType
AnchorNe
  succ AnchorType
AnchorNe = AnchorType
AnchorS
  succ AnchorType
AnchorS = AnchorType
AnchorSw
  succ AnchorType
AnchorSw = AnchorType
AnchorSe
  succ AnchorType
AnchorSe = AnchorType
AnchorW
  succ AnchorType
AnchorW = AnchorType
AnchorE
  succ AnchorType
_ = AnchorType
forall a. HasCallStack => a
undefined

  pred :: AnchorType -> AnchorType
pred AnchorType
AnchorNorth = AnchorType
AnchorCenter
  pred AnchorType
AnchorNorthWest = AnchorType
AnchorNorth
  pred AnchorType
AnchorNorthEast = AnchorType
AnchorNorthWest
  pred AnchorType
AnchorSouth = AnchorType
AnchorNorthEast
  pred AnchorType
AnchorSouthWest = AnchorType
AnchorSouth
  pred AnchorType
AnchorSouthEast = AnchorType
AnchorSouthWest
  pred AnchorType
AnchorWest = AnchorType
AnchorSouthEast
  pred AnchorType
AnchorEast = AnchorType
AnchorWest
  pred AnchorType
AnchorN = AnchorType
AnchorEast
  pred AnchorType
AnchorNw = AnchorType
AnchorN
  pred AnchorType
AnchorNe = AnchorType
AnchorNw
  pred AnchorType
AnchorS = AnchorType
AnchorNe
  pred AnchorType
AnchorSw = AnchorType
AnchorS
  pred AnchorType
AnchorSe = AnchorType
AnchorSw
  pred AnchorType
AnchorW = AnchorType
AnchorSe
  pred AnchorType
AnchorE = AnchorType
AnchorW
  pred AnchorType
_ = AnchorType
forall a. HasCallStack => a
undefined

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

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