#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gtk.Enums
(
Align(..) ,
ArrowPlacement(..) ,
ArrowType(..) ,
AssistantPageType(..) ,
BaselinePosition(..) ,
BorderStyle(..) ,
BuilderError(..) ,
catchBuilderError ,
handleBuilderError ,
ButtonBoxStyle(..) ,
ButtonRole(..) ,
ButtonsType(..) ,
CellRendererAccelMode(..) ,
CellRendererMode(..) ,
CornerType(..) ,
CssProviderError(..) ,
catchCssProviderError ,
handleCssProviderError ,
CssSectionType(..) ,
DeleteType(..) ,
DirectionType(..) ,
DragResult(..) ,
EntryIconPosition(..) ,
EventSequenceState(..) ,
ExpanderStyle(..) ,
FileChooserAction(..) ,
FileChooserConfirmation(..) ,
FileChooserError(..) ,
catchFileChooserError ,
handleFileChooserError ,
IMPreeditStyle(..) ,
IMStatusStyle(..) ,
IconSize(..) ,
IconThemeError(..) ,
catchIconThemeError ,
handleIconThemeError ,
IconViewDropPosition(..) ,
ImageType(..) ,
InputPurpose(..) ,
Justification(..) ,
LevelBarMode(..) ,
License(..) ,
MenuDirectionType(..) ,
MessageType(..) ,
MovementStep(..) ,
NotebookTab(..) ,
NumberUpLayout(..) ,
Orientation(..) ,
PackDirection(..) ,
PackType(..) ,
PadActionType(..) ,
PageOrientation(..) ,
PageSet(..) ,
PanDirection(..) ,
PathPriorityType(..) ,
PathType(..) ,
PolicyType(..) ,
PopoverConstraint(..) ,
PositionType(..) ,
PrintDuplex(..) ,
PrintError(..) ,
catchPrintError ,
handlePrintError ,
PrintOperationAction(..) ,
PrintOperationResult(..) ,
PrintPages(..) ,
PrintQuality(..) ,
PrintStatus(..) ,
PropagationPhase(..) ,
RcTokenType(..) ,
RecentChooserError(..) ,
catchRecentChooserError ,
handleRecentChooserError ,
RecentManagerError(..) ,
catchRecentManagerError ,
handleRecentManagerError ,
RecentSortType(..) ,
ReliefStyle(..) ,
ResizeMode(..) ,
ResponseType(..) ,
RevealerTransitionType(..) ,
ScrollStep(..) ,
ScrollType(..) ,
ScrollablePolicy(..) ,
SelectionMode(..) ,
SensitivityType(..) ,
ShadowType(..) ,
ShortcutType(..) ,
SizeGroupMode(..) ,
SizeRequestMode(..) ,
SortType(..) ,
SpinButtonUpdatePolicy(..) ,
SpinType(..) ,
StackTransitionType(..) ,
StateType(..) ,
TextBufferTargetInfo(..) ,
TextDirection(..) ,
TextExtendSelection(..) ,
TextViewLayer(..) ,
TextWindowType(..) ,
ToolbarSpaceStyle(..) ,
ToolbarStyle(..) ,
TreeViewColumnSizing(..) ,
TreeViewDropPosition(..) ,
TreeViewGridLines(..) ,
Unit(..) ,
WidgetHelpType(..) ,
WindowPosition(..) ,
WindowType(..) ,
WrapMode(..) ,
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R
data WrapMode =
WrapModeNone
| WrapModeChar
| WrapModeWord
| WrapModeWordChar
| AnotherWrapMode Int
deriving (Int -> WrapMode -> ShowS
[WrapMode] -> ShowS
WrapMode -> String
(Int -> WrapMode -> ShowS)
-> (WrapMode -> String) -> ([WrapMode] -> ShowS) -> Show WrapMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [WrapMode] -> ShowS
$cshowList :: [WrapMode] -> ShowS
show :: WrapMode -> String
$cshow :: WrapMode -> String
showsPrec :: Int -> WrapMode -> ShowS
$cshowsPrec :: Int -> WrapMode -> ShowS
Show, WrapMode -> WrapMode -> Bool
(WrapMode -> WrapMode -> Bool)
-> (WrapMode -> WrapMode -> Bool) -> Eq WrapMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: WrapMode -> WrapMode -> Bool
$c/= :: WrapMode -> WrapMode -> Bool
== :: WrapMode -> WrapMode -> Bool
$c== :: WrapMode -> WrapMode -> Bool
Eq)
instance P.Enum WrapMode where
fromEnum :: WrapMode -> Int
fromEnum WrapMode
WrapModeNone = Int
0
fromEnum WrapMode
WrapModeChar = Int
1
fromEnum WrapMode
WrapModeWord = Int
2
fromEnum WrapMode
WrapModeWordChar = Int
3
fromEnum (AnotherWrapMode Int
k) = Int
k
toEnum :: Int -> WrapMode
toEnum Int
0 = WrapMode
WrapModeNone
toEnum Int
1 = WrapMode
WrapModeChar
toEnum Int
2 = WrapMode
WrapModeWord
toEnum Int
3 = WrapMode
WrapModeWordChar
toEnum Int
k = Int -> WrapMode
AnotherWrapMode Int
k
instance P.Ord WrapMode where
compare :: WrapMode -> WrapMode -> Ordering
compare WrapMode
a WrapMode
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (WrapMode -> Int
forall a. Enum a => a -> Int
P.fromEnum WrapMode
a) (WrapMode -> Int
forall a. Enum a => a -> Int
P.fromEnum WrapMode
b)
type instance O.ParentTypes WrapMode = '[]
instance O.HasParentTypes WrapMode
foreign import ccall "gtk_wrap_mode_get_type" c_gtk_wrap_mode_get_type ::
IO GType
instance B.Types.TypedObject WrapMode where
glibType :: IO GType
glibType = IO GType
c_gtk_wrap_mode_get_type
instance B.Types.BoxedEnum WrapMode
data WindowType =
WindowTypeToplevel
|
| AnotherWindowType Int
deriving (Int -> WindowType -> ShowS
[WindowType] -> ShowS
WindowType -> String
(Int -> WindowType -> ShowS)
-> (WindowType -> String)
-> ([WindowType] -> ShowS)
-> Show WindowType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [WindowType] -> ShowS
$cshowList :: [WindowType] -> ShowS
show :: WindowType -> String
$cshow :: WindowType -> String
showsPrec :: Int -> WindowType -> ShowS
$cshowsPrec :: Int -> WindowType -> ShowS
Show, WindowType -> WindowType -> Bool
(WindowType -> WindowType -> Bool)
-> (WindowType -> WindowType -> Bool) -> Eq WindowType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: WindowType -> WindowType -> Bool
$c/= :: WindowType -> WindowType -> Bool
== :: WindowType -> WindowType -> Bool
$c== :: WindowType -> WindowType -> Bool
Eq)
instance P.Enum WindowType where
fromEnum :: WindowType -> Int
fromEnum WindowType
WindowTypeToplevel = Int
0
fromEnum WindowType
WindowTypePopup = Int
1
fromEnum (AnotherWindowType Int
k) = Int
k
toEnum :: Int -> WindowType
toEnum Int
0 = WindowType
WindowTypeToplevel
toEnum Int
1 = WindowType
WindowTypePopup
toEnum Int
k = Int -> WindowType
AnotherWindowType Int
k
instance P.Ord WindowType where
compare :: WindowType -> WindowType -> Ordering
compare WindowType
a WindowType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (WindowType -> Int
forall a. Enum a => a -> Int
P.fromEnum WindowType
a) (WindowType -> Int
forall a. Enum a => a -> Int
P.fromEnum WindowType
b)
type instance O.ParentTypes WindowType = '[]
instance O.HasParentTypes WindowType
foreign import ccall "gtk_window_type_get_type" c_gtk_window_type_get_type ::
IO GType
instance B.Types.TypedObject WindowType where
glibType :: IO GType
glibType = IO GType
c_gtk_window_type_get_type
instance B.Types.BoxedEnum WindowType
data WindowPosition =
WindowPositionNone
| WindowPositionCenter
| WindowPositionMouse
| WindowPositionCenterAlways
| WindowPositionCenterOnParent
| AnotherWindowPosition Int
deriving (Int -> WindowPosition -> ShowS
[WindowPosition] -> ShowS
WindowPosition -> String
(Int -> WindowPosition -> ShowS)
-> (WindowPosition -> String)
-> ([WindowPosition] -> ShowS)
-> Show WindowPosition
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [WindowPosition] -> ShowS
$cshowList :: [WindowPosition] -> ShowS
show :: WindowPosition -> String
$cshow :: WindowPosition -> String
showsPrec :: Int -> WindowPosition -> ShowS
$cshowsPrec :: Int -> WindowPosition -> ShowS
Show, WindowPosition -> WindowPosition -> Bool
(WindowPosition -> WindowPosition -> Bool)
-> (WindowPosition -> WindowPosition -> Bool) -> Eq WindowPosition
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: WindowPosition -> WindowPosition -> Bool
$c/= :: WindowPosition -> WindowPosition -> Bool
== :: WindowPosition -> WindowPosition -> Bool
$c== :: WindowPosition -> WindowPosition -> Bool
Eq)
instance P.Enum WindowPosition where
fromEnum :: WindowPosition -> Int
fromEnum WindowPosition
WindowPositionNone = Int
0
fromEnum WindowPosition
WindowPositionCenter = Int
1
fromEnum WindowPosition
WindowPositionMouse = Int
2
fromEnum WindowPosition
WindowPositionCenterAlways = Int
3
fromEnum WindowPosition
WindowPositionCenterOnParent = Int
4
fromEnum (AnotherWindowPosition Int
k) = Int
k
toEnum :: Int -> WindowPosition
toEnum Int
0 = WindowPosition
WindowPositionNone
toEnum Int
1 = WindowPosition
WindowPositionCenter
toEnum Int
2 = WindowPosition
WindowPositionMouse
toEnum Int
3 = WindowPosition
WindowPositionCenterAlways
toEnum Int
4 = WindowPosition
WindowPositionCenterOnParent
toEnum Int
k = Int -> WindowPosition
AnotherWindowPosition Int
k
instance P.Ord WindowPosition where
compare :: WindowPosition -> WindowPosition -> Ordering
compare WindowPosition
a WindowPosition
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (WindowPosition -> Int
forall a. Enum a => a -> Int
P.fromEnum WindowPosition
a) (WindowPosition -> Int
forall a. Enum a => a -> Int
P.fromEnum WindowPosition
b)
type instance O.ParentTypes WindowPosition = '[]
instance O.HasParentTypes WindowPosition
foreign import ccall "gtk_window_position_get_type" c_gtk_window_position_get_type ::
IO GType
instance B.Types.TypedObject WindowPosition where
glibType :: IO GType
glibType = IO GType
c_gtk_window_position_get_type
instance B.Types.BoxedEnum WindowPosition
data WidgetHelpType =
WidgetHelpTypeTooltip
| WidgetHelpTypeWhatsThis
| AnotherWidgetHelpType Int
deriving (Int -> WidgetHelpType -> ShowS
[WidgetHelpType] -> ShowS
WidgetHelpType -> String
(Int -> WidgetHelpType -> ShowS)
-> (WidgetHelpType -> String)
-> ([WidgetHelpType] -> ShowS)
-> Show WidgetHelpType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [WidgetHelpType] -> ShowS
$cshowList :: [WidgetHelpType] -> ShowS
show :: WidgetHelpType -> String
$cshow :: WidgetHelpType -> String
showsPrec :: Int -> WidgetHelpType -> ShowS
$cshowsPrec :: Int -> WidgetHelpType -> ShowS
Show, WidgetHelpType -> WidgetHelpType -> Bool
(WidgetHelpType -> WidgetHelpType -> Bool)
-> (WidgetHelpType -> WidgetHelpType -> Bool) -> Eq WidgetHelpType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: WidgetHelpType -> WidgetHelpType -> Bool
$c/= :: WidgetHelpType -> WidgetHelpType -> Bool
== :: WidgetHelpType -> WidgetHelpType -> Bool
$c== :: WidgetHelpType -> WidgetHelpType -> Bool
Eq)
instance P.Enum WidgetHelpType where
fromEnum :: WidgetHelpType -> Int
fromEnum WidgetHelpType
WidgetHelpTypeTooltip = Int
0
fromEnum WidgetHelpType
WidgetHelpTypeWhatsThis = Int
1
fromEnum (AnotherWidgetHelpType Int
k) = Int
k
toEnum :: Int -> WidgetHelpType
toEnum Int
0 = WidgetHelpType
WidgetHelpTypeTooltip
toEnum Int
1 = WidgetHelpType
WidgetHelpTypeWhatsThis
toEnum Int
k = Int -> WidgetHelpType
AnotherWidgetHelpType Int
k
instance P.Ord WidgetHelpType where
compare :: WidgetHelpType -> WidgetHelpType -> Ordering
compare WidgetHelpType
a WidgetHelpType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (WidgetHelpType -> Int
forall a. Enum a => a -> Int
P.fromEnum WidgetHelpType
a) (WidgetHelpType -> Int
forall a. Enum a => a -> Int
P.fromEnum WidgetHelpType
b)
type instance O.ParentTypes WidgetHelpType = '[]
instance O.HasParentTypes WidgetHelpType
foreign import ccall "gtk_widget_help_type_get_type" c_gtk_widget_help_type_get_type ::
IO GType
instance B.Types.TypedObject WidgetHelpType where
glibType :: IO GType
glibType = IO GType
c_gtk_widget_help_type_get_type
instance B.Types.BoxedEnum WidgetHelpType
data Unit =
UnitNone
| UnitPoints
| UnitInch
| UnitMm
| AnotherUnit Int
deriving (Int -> Unit -> ShowS
[Unit] -> ShowS
Unit -> String
(Int -> Unit -> ShowS)
-> (Unit -> String) -> ([Unit] -> ShowS) -> Show Unit
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Unit] -> ShowS
$cshowList :: [Unit] -> ShowS
show :: Unit -> String
$cshow :: Unit -> String
showsPrec :: Int -> Unit -> ShowS
$cshowsPrec :: Int -> Unit -> ShowS
Show, Unit -> Unit -> Bool
(Unit -> Unit -> Bool) -> (Unit -> Unit -> Bool) -> Eq Unit
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Unit -> Unit -> Bool
$c/= :: Unit -> Unit -> Bool
== :: Unit -> Unit -> Bool
$c== :: Unit -> Unit -> Bool
Eq)
instance P.Enum Unit where
fromEnum :: Unit -> Int
fromEnum Unit
UnitNone = Int
0
fromEnum Unit
UnitPoints = Int
1
fromEnum Unit
UnitInch = Int
2
fromEnum Unit
UnitMm = Int
3
fromEnum (AnotherUnit Int
k) = Int
k
toEnum :: Int -> Unit
toEnum Int
0 = Unit
UnitNone
toEnum Int
1 = Unit
UnitPoints
toEnum Int
2 = Unit
UnitInch
toEnum Int
3 = Unit
UnitMm
toEnum Int
k = Int -> Unit
AnotherUnit Int
k
instance P.Ord Unit where
compare :: Unit -> Unit -> Ordering
compare Unit
a Unit
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (Unit -> Int
forall a. Enum a => a -> Int
P.fromEnum Unit
a) (Unit -> Int
forall a. Enum a => a -> Int
P.fromEnum Unit
b)
type instance O.ParentTypes Unit = '[]
instance O.HasParentTypes Unit
foreign import ccall "gtk_unit_get_type" c_gtk_unit_get_type ::
IO GType
instance B.Types.TypedObject Unit where
glibType :: IO GType
glibType = IO GType
c_gtk_unit_get_type
instance B.Types.BoxedEnum Unit
data TreeViewGridLines =
TreeViewGridLinesNone
| TreeViewGridLinesHorizontal
| TreeViewGridLinesVertical
| TreeViewGridLinesBoth
| AnotherTreeViewGridLines Int
deriving (Int -> TreeViewGridLines -> ShowS
[TreeViewGridLines] -> ShowS
TreeViewGridLines -> String
(Int -> TreeViewGridLines -> ShowS)
-> (TreeViewGridLines -> String)
-> ([TreeViewGridLines] -> ShowS)
-> Show TreeViewGridLines
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TreeViewGridLines] -> ShowS
$cshowList :: [TreeViewGridLines] -> ShowS
show :: TreeViewGridLines -> String
$cshow :: TreeViewGridLines -> String
showsPrec :: Int -> TreeViewGridLines -> ShowS
$cshowsPrec :: Int -> TreeViewGridLines -> ShowS
Show, TreeViewGridLines -> TreeViewGridLines -> Bool
(TreeViewGridLines -> TreeViewGridLines -> Bool)
-> (TreeViewGridLines -> TreeViewGridLines -> Bool)
-> Eq TreeViewGridLines
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TreeViewGridLines -> TreeViewGridLines -> Bool
$c/= :: TreeViewGridLines -> TreeViewGridLines -> Bool
== :: TreeViewGridLines -> TreeViewGridLines -> Bool
$c== :: TreeViewGridLines -> TreeViewGridLines -> Bool
Eq)
instance P.Enum TreeViewGridLines where
fromEnum :: TreeViewGridLines -> Int
fromEnum TreeViewGridLines
TreeViewGridLinesNone = Int
0
fromEnum TreeViewGridLines
TreeViewGridLinesHorizontal = Int
1
fromEnum TreeViewGridLines
TreeViewGridLinesVertical = Int
2
fromEnum TreeViewGridLines
TreeViewGridLinesBoth = Int
3
fromEnum (AnotherTreeViewGridLines Int
k) = Int
k
toEnum :: Int -> TreeViewGridLines
toEnum Int
0 = TreeViewGridLines
TreeViewGridLinesNone
toEnum Int
1 = TreeViewGridLines
TreeViewGridLinesHorizontal
toEnum Int
2 = TreeViewGridLines
TreeViewGridLinesVertical
toEnum Int
3 = TreeViewGridLines
TreeViewGridLinesBoth
toEnum Int
k = Int -> TreeViewGridLines
AnotherTreeViewGridLines Int
k
instance P.Ord TreeViewGridLines where
compare :: TreeViewGridLines -> TreeViewGridLines -> Ordering
compare TreeViewGridLines
a TreeViewGridLines
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (TreeViewGridLines -> Int
forall a. Enum a => a -> Int
P.fromEnum TreeViewGridLines
a) (TreeViewGridLines -> Int
forall a. Enum a => a -> Int
P.fromEnum TreeViewGridLines
b)
type instance O.ParentTypes TreeViewGridLines = '[]
instance O.HasParentTypes TreeViewGridLines
foreign import ccall "gtk_tree_view_grid_lines_get_type" c_gtk_tree_view_grid_lines_get_type ::
IO GType
instance B.Types.TypedObject TreeViewGridLines where
glibType :: IO GType
glibType = IO GType
c_gtk_tree_view_grid_lines_get_type
instance B.Types.BoxedEnum TreeViewGridLines
data TreeViewDropPosition =
TreeViewDropPositionBefore
| TreeViewDropPositionAfter
| TreeViewDropPositionIntoOrBefore
| TreeViewDropPositionIntoOrAfter
| AnotherTreeViewDropPosition Int
deriving (Int -> TreeViewDropPosition -> ShowS
[TreeViewDropPosition] -> ShowS
TreeViewDropPosition -> String
(Int -> TreeViewDropPosition -> ShowS)
-> (TreeViewDropPosition -> String)
-> ([TreeViewDropPosition] -> ShowS)
-> Show TreeViewDropPosition
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TreeViewDropPosition] -> ShowS
$cshowList :: [TreeViewDropPosition] -> ShowS
show :: TreeViewDropPosition -> String
$cshow :: TreeViewDropPosition -> String
showsPrec :: Int -> TreeViewDropPosition -> ShowS
$cshowsPrec :: Int -> TreeViewDropPosition -> ShowS
Show, TreeViewDropPosition -> TreeViewDropPosition -> Bool
(TreeViewDropPosition -> TreeViewDropPosition -> Bool)
-> (TreeViewDropPosition -> TreeViewDropPosition -> Bool)
-> Eq TreeViewDropPosition
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TreeViewDropPosition -> TreeViewDropPosition -> Bool
$c/= :: TreeViewDropPosition -> TreeViewDropPosition -> Bool
== :: TreeViewDropPosition -> TreeViewDropPosition -> Bool
$c== :: TreeViewDropPosition -> TreeViewDropPosition -> Bool
Eq)
instance P.Enum TreeViewDropPosition where
fromEnum :: TreeViewDropPosition -> Int
fromEnum TreeViewDropPosition
TreeViewDropPositionBefore = Int
0
fromEnum TreeViewDropPosition
TreeViewDropPositionAfter = Int
1
fromEnum TreeViewDropPosition
TreeViewDropPositionIntoOrBefore = Int
2
fromEnum TreeViewDropPosition
TreeViewDropPositionIntoOrAfter = Int
3
fromEnum (AnotherTreeViewDropPosition Int
k) = Int
k
toEnum :: Int -> TreeViewDropPosition
toEnum Int
0 = TreeViewDropPosition
TreeViewDropPositionBefore
toEnum Int
1 = TreeViewDropPosition
TreeViewDropPositionAfter
toEnum Int
2 = TreeViewDropPosition
TreeViewDropPositionIntoOrBefore
toEnum Int
3 = TreeViewDropPosition
TreeViewDropPositionIntoOrAfter
toEnum Int
k = Int -> TreeViewDropPosition
AnotherTreeViewDropPosition Int
k
instance P.Ord TreeViewDropPosition where
compare :: TreeViewDropPosition -> TreeViewDropPosition -> Ordering
compare TreeViewDropPosition
a TreeViewDropPosition
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (TreeViewDropPosition -> Int
forall a. Enum a => a -> Int
P.fromEnum TreeViewDropPosition
a) (TreeViewDropPosition -> Int
forall a. Enum a => a -> Int
P.fromEnum TreeViewDropPosition
b)
type instance O.ParentTypes TreeViewDropPosition = '[]
instance O.HasParentTypes TreeViewDropPosition
foreign import ccall "gtk_tree_view_drop_position_get_type" c_gtk_tree_view_drop_position_get_type ::
IO GType
instance B.Types.TypedObject TreeViewDropPosition where
glibType :: IO GType
glibType = IO GType
c_gtk_tree_view_drop_position_get_type
instance B.Types.BoxedEnum TreeViewDropPosition
data TreeViewColumnSizing =
TreeViewColumnSizingGrowOnly
| TreeViewColumnSizingAutosize
| TreeViewColumnSizingFixed
| AnotherTreeViewColumnSizing Int
deriving (Int -> TreeViewColumnSizing -> ShowS
[TreeViewColumnSizing] -> ShowS
TreeViewColumnSizing -> String
(Int -> TreeViewColumnSizing -> ShowS)
-> (TreeViewColumnSizing -> String)
-> ([TreeViewColumnSizing] -> ShowS)
-> Show TreeViewColumnSizing
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TreeViewColumnSizing] -> ShowS
$cshowList :: [TreeViewColumnSizing] -> ShowS
show :: TreeViewColumnSizing -> String
$cshow :: TreeViewColumnSizing -> String
showsPrec :: Int -> TreeViewColumnSizing -> ShowS
$cshowsPrec :: Int -> TreeViewColumnSizing -> ShowS
Show, TreeViewColumnSizing -> TreeViewColumnSizing -> Bool
(TreeViewColumnSizing -> TreeViewColumnSizing -> Bool)
-> (TreeViewColumnSizing -> TreeViewColumnSizing -> Bool)
-> Eq TreeViewColumnSizing
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TreeViewColumnSizing -> TreeViewColumnSizing -> Bool
$c/= :: TreeViewColumnSizing -> TreeViewColumnSizing -> Bool
== :: TreeViewColumnSizing -> TreeViewColumnSizing -> Bool
$c== :: TreeViewColumnSizing -> TreeViewColumnSizing -> Bool
Eq)
instance P.Enum TreeViewColumnSizing where
fromEnum :: TreeViewColumnSizing -> Int
fromEnum TreeViewColumnSizing
TreeViewColumnSizingGrowOnly = Int
0
fromEnum TreeViewColumnSizing
TreeViewColumnSizingAutosize = Int
1
fromEnum TreeViewColumnSizing
TreeViewColumnSizingFixed = Int
2
fromEnum (AnotherTreeViewColumnSizing Int
k) = Int
k
toEnum :: Int -> TreeViewColumnSizing
toEnum Int
0 = TreeViewColumnSizing
TreeViewColumnSizingGrowOnly
toEnum Int
1 = TreeViewColumnSizing
TreeViewColumnSizingAutosize
toEnum Int
2 = TreeViewColumnSizing
TreeViewColumnSizingFixed
toEnum Int
k = Int -> TreeViewColumnSizing
AnotherTreeViewColumnSizing Int
k
instance P.Ord TreeViewColumnSizing where
compare :: TreeViewColumnSizing -> TreeViewColumnSizing -> Ordering
compare TreeViewColumnSizing
a TreeViewColumnSizing
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (TreeViewColumnSizing -> Int
forall a. Enum a => a -> Int
P.fromEnum TreeViewColumnSizing
a) (TreeViewColumnSizing -> Int
forall a. Enum a => a -> Int
P.fromEnum TreeViewColumnSizing
b)
type instance O.ParentTypes TreeViewColumnSizing = '[]
instance O.HasParentTypes TreeViewColumnSizing
foreign import ccall "gtk_tree_view_column_sizing_get_type" c_gtk_tree_view_column_sizing_get_type ::
IO GType
instance B.Types.TypedObject TreeViewColumnSizing where
glibType :: IO GType
glibType = IO GType
c_gtk_tree_view_column_sizing_get_type
instance B.Types.BoxedEnum TreeViewColumnSizing
data ToolbarStyle =
ToolbarStyleIcons
| ToolbarStyleText
| ToolbarStyleBoth
| ToolbarStyleBothHoriz
| AnotherToolbarStyle Int
deriving (Int -> ToolbarStyle -> ShowS
[ToolbarStyle] -> ShowS
ToolbarStyle -> String
(Int -> ToolbarStyle -> ShowS)
-> (ToolbarStyle -> String)
-> ([ToolbarStyle] -> ShowS)
-> Show ToolbarStyle
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ToolbarStyle] -> ShowS
$cshowList :: [ToolbarStyle] -> ShowS
show :: ToolbarStyle -> String
$cshow :: ToolbarStyle -> String
showsPrec :: Int -> ToolbarStyle -> ShowS
$cshowsPrec :: Int -> ToolbarStyle -> ShowS
Show, ToolbarStyle -> ToolbarStyle -> Bool
(ToolbarStyle -> ToolbarStyle -> Bool)
-> (ToolbarStyle -> ToolbarStyle -> Bool) -> Eq ToolbarStyle
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ToolbarStyle -> ToolbarStyle -> Bool
$c/= :: ToolbarStyle -> ToolbarStyle -> Bool
== :: ToolbarStyle -> ToolbarStyle -> Bool
$c== :: ToolbarStyle -> ToolbarStyle -> Bool
Eq)
instance P.Enum ToolbarStyle where
fromEnum :: ToolbarStyle -> Int
fromEnum ToolbarStyle
ToolbarStyleIcons = Int
0
fromEnum ToolbarStyle
ToolbarStyleText = Int
1
fromEnum ToolbarStyle
ToolbarStyleBoth = Int
2
fromEnum ToolbarStyle
ToolbarStyleBothHoriz = Int
3
fromEnum (AnotherToolbarStyle Int
k) = Int
k
toEnum :: Int -> ToolbarStyle
toEnum Int
0 = ToolbarStyle
ToolbarStyleIcons
toEnum Int
1 = ToolbarStyle
ToolbarStyleText
toEnum Int
2 = ToolbarStyle
ToolbarStyleBoth
toEnum Int
3 = ToolbarStyle
ToolbarStyleBothHoriz
toEnum Int
k = Int -> ToolbarStyle
AnotherToolbarStyle Int
k
instance P.Ord ToolbarStyle where
compare :: ToolbarStyle -> ToolbarStyle -> Ordering
compare ToolbarStyle
a ToolbarStyle
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ToolbarStyle -> Int
forall a. Enum a => a -> Int
P.fromEnum ToolbarStyle
a) (ToolbarStyle -> Int
forall a. Enum a => a -> Int
P.fromEnum ToolbarStyle
b)
type instance O.ParentTypes ToolbarStyle = '[]
instance O.HasParentTypes ToolbarStyle
foreign import ccall "gtk_toolbar_style_get_type" c_gtk_toolbar_style_get_type ::
IO GType
instance B.Types.TypedObject ToolbarStyle where
glibType :: IO GType
glibType = IO GType
c_gtk_toolbar_style_get_type
instance B.Types.BoxedEnum ToolbarStyle
{-# DEPRECATED ToolbarSpaceStyle ["(Since version 3.20)"] #-}
data ToolbarSpaceStyle =
ToolbarSpaceStyleEmpty
| ToolbarSpaceStyleLine
| AnotherToolbarSpaceStyle Int
deriving (Int -> ToolbarSpaceStyle -> ShowS
[ToolbarSpaceStyle] -> ShowS
ToolbarSpaceStyle -> String
(Int -> ToolbarSpaceStyle -> ShowS)
-> (ToolbarSpaceStyle -> String)
-> ([ToolbarSpaceStyle] -> ShowS)
-> Show ToolbarSpaceStyle
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ToolbarSpaceStyle] -> ShowS
$cshowList :: [ToolbarSpaceStyle] -> ShowS
show :: ToolbarSpaceStyle -> String
$cshow :: ToolbarSpaceStyle -> String
showsPrec :: Int -> ToolbarSpaceStyle -> ShowS
$cshowsPrec :: Int -> ToolbarSpaceStyle -> ShowS
Show, ToolbarSpaceStyle -> ToolbarSpaceStyle -> Bool
(ToolbarSpaceStyle -> ToolbarSpaceStyle -> Bool)
-> (ToolbarSpaceStyle -> ToolbarSpaceStyle -> Bool)
-> Eq ToolbarSpaceStyle
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ToolbarSpaceStyle -> ToolbarSpaceStyle -> Bool
$c/= :: ToolbarSpaceStyle -> ToolbarSpaceStyle -> Bool
== :: ToolbarSpaceStyle -> ToolbarSpaceStyle -> Bool
$c== :: ToolbarSpaceStyle -> ToolbarSpaceStyle -> Bool
Eq)
instance P.Enum ToolbarSpaceStyle where
fromEnum :: ToolbarSpaceStyle -> Int
fromEnum ToolbarSpaceStyle
ToolbarSpaceStyleEmpty = Int
0
fromEnum ToolbarSpaceStyle
ToolbarSpaceStyleLine = Int
1
fromEnum (AnotherToolbarSpaceStyle Int
k) = Int
k
toEnum :: Int -> ToolbarSpaceStyle
toEnum Int
0 = ToolbarSpaceStyle
ToolbarSpaceStyleEmpty
toEnum Int
1 = ToolbarSpaceStyle
ToolbarSpaceStyleLine
toEnum Int
k = Int -> ToolbarSpaceStyle
AnotherToolbarSpaceStyle Int
k
instance P.Ord ToolbarSpaceStyle where
compare :: ToolbarSpaceStyle -> ToolbarSpaceStyle -> Ordering
compare ToolbarSpaceStyle
a ToolbarSpaceStyle
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ToolbarSpaceStyle -> Int
forall a. Enum a => a -> Int
P.fromEnum ToolbarSpaceStyle
a) (ToolbarSpaceStyle -> Int
forall a. Enum a => a -> Int
P.fromEnum ToolbarSpaceStyle
b)
type instance O.ParentTypes ToolbarSpaceStyle = '[]
instance O.HasParentTypes ToolbarSpaceStyle
foreign import ccall "gtk_toolbar_space_style_get_type" c_gtk_toolbar_space_style_get_type ::
IO GType
instance B.Types.TypedObject ToolbarSpaceStyle where
glibType :: IO GType
glibType = IO GType
c_gtk_toolbar_space_style_get_type
instance B.Types.BoxedEnum ToolbarSpaceStyle
data TextWindowType =
TextWindowTypePrivate
| TextWindowTypeWidget
| TextWindowTypeText
| TextWindowTypeLeft
| TextWindowTypeRight
| TextWindowTypeTop
| TextWindowTypeBottom
| AnotherTextWindowType Int
deriving (Int -> TextWindowType -> ShowS
[TextWindowType] -> ShowS
TextWindowType -> String
(Int -> TextWindowType -> ShowS)
-> (TextWindowType -> String)
-> ([TextWindowType] -> ShowS)
-> Show TextWindowType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TextWindowType] -> ShowS
$cshowList :: [TextWindowType] -> ShowS
show :: TextWindowType -> String
$cshow :: TextWindowType -> String
showsPrec :: Int -> TextWindowType -> ShowS
$cshowsPrec :: Int -> TextWindowType -> ShowS
Show, TextWindowType -> TextWindowType -> Bool
(TextWindowType -> TextWindowType -> Bool)
-> (TextWindowType -> TextWindowType -> Bool) -> Eq TextWindowType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TextWindowType -> TextWindowType -> Bool
$c/= :: TextWindowType -> TextWindowType -> Bool
== :: TextWindowType -> TextWindowType -> Bool
$c== :: TextWindowType -> TextWindowType -> Bool
Eq)
instance P.Enum TextWindowType where
fromEnum :: TextWindowType -> Int
fromEnum TextWindowType
TextWindowTypePrivate = Int
0
fromEnum TextWindowType
TextWindowTypeWidget = Int
1
fromEnum TextWindowType
TextWindowTypeText = Int
2
fromEnum TextWindowType
TextWindowTypeLeft = Int
3
fromEnum TextWindowType
TextWindowTypeRight = Int
4
fromEnum TextWindowType
TextWindowTypeTop = Int
5
fromEnum TextWindowType
TextWindowTypeBottom = Int
6
fromEnum (AnotherTextWindowType Int
k) = Int
k
toEnum :: Int -> TextWindowType
toEnum Int
0 = TextWindowType
TextWindowTypePrivate
toEnum Int
1 = TextWindowType
TextWindowTypeWidget
toEnum Int
2 = TextWindowType
TextWindowTypeText
toEnum Int
3 = TextWindowType
TextWindowTypeLeft
toEnum Int
4 = TextWindowType
TextWindowTypeRight
toEnum Int
5 = TextWindowType
TextWindowTypeTop
toEnum Int
6 = TextWindowType
TextWindowTypeBottom
toEnum Int
k = Int -> TextWindowType
AnotherTextWindowType Int
k
instance P.Ord TextWindowType where
compare :: TextWindowType -> TextWindowType -> Ordering
compare TextWindowType
a TextWindowType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (TextWindowType -> Int
forall a. Enum a => a -> Int
P.fromEnum TextWindowType
a) (TextWindowType -> Int
forall a. Enum a => a -> Int
P.fromEnum TextWindowType
b)
type instance O.ParentTypes TextWindowType = '[]
instance O.HasParentTypes TextWindowType
foreign import ccall "gtk_text_window_type_get_type" c_gtk_text_window_type_get_type ::
IO GType
instance B.Types.TypedObject TextWindowType where
glibType :: IO GType
glibType = IO GType
c_gtk_text_window_type_get_type
instance B.Types.BoxedEnum TextWindowType
data TextViewLayer =
TextViewLayerBelow
| TextViewLayerAbove
| TextViewLayerBelowText
| TextViewLayerAboveText
| AnotherTextViewLayer Int
deriving (Int -> TextViewLayer -> ShowS
[TextViewLayer] -> ShowS
TextViewLayer -> String
(Int -> TextViewLayer -> ShowS)
-> (TextViewLayer -> String)
-> ([TextViewLayer] -> ShowS)
-> Show TextViewLayer
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TextViewLayer] -> ShowS
$cshowList :: [TextViewLayer] -> ShowS
show :: TextViewLayer -> String
$cshow :: TextViewLayer -> String
showsPrec :: Int -> TextViewLayer -> ShowS
$cshowsPrec :: Int -> TextViewLayer -> ShowS
Show, TextViewLayer -> TextViewLayer -> Bool
(TextViewLayer -> TextViewLayer -> Bool)
-> (TextViewLayer -> TextViewLayer -> Bool) -> Eq TextViewLayer
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TextViewLayer -> TextViewLayer -> Bool
$c/= :: TextViewLayer -> TextViewLayer -> Bool
== :: TextViewLayer -> TextViewLayer -> Bool
$c== :: TextViewLayer -> TextViewLayer -> Bool
Eq)
instance P.Enum TextViewLayer where
fromEnum :: TextViewLayer -> Int
fromEnum TextViewLayer
TextViewLayerBelow = Int
0
fromEnum TextViewLayer
TextViewLayerAbove = Int
1
fromEnum TextViewLayer
TextViewLayerBelowText = Int
2
fromEnum TextViewLayer
TextViewLayerAboveText = Int
3
fromEnum (AnotherTextViewLayer Int
k) = Int
k
toEnum :: Int -> TextViewLayer
toEnum Int
0 = TextViewLayer
TextViewLayerBelow
toEnum Int
1 = TextViewLayer
TextViewLayerAbove
toEnum Int
2 = TextViewLayer
TextViewLayerBelowText
toEnum Int
3 = TextViewLayer
TextViewLayerAboveText
toEnum Int
k = Int -> TextViewLayer
AnotherTextViewLayer Int
k
instance P.Ord TextViewLayer where
compare :: TextViewLayer -> TextViewLayer -> Ordering
compare TextViewLayer
a TextViewLayer
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (TextViewLayer -> Int
forall a. Enum a => a -> Int
P.fromEnum TextViewLayer
a) (TextViewLayer -> Int
forall a. Enum a => a -> Int
P.fromEnum TextViewLayer
b)
type instance O.ParentTypes TextViewLayer = '[]
instance O.HasParentTypes TextViewLayer
foreign import ccall "gtk_text_view_layer_get_type" c_gtk_text_view_layer_get_type ::
IO GType
instance B.Types.TypedObject TextViewLayer where
glibType :: IO GType
glibType = IO GType
c_gtk_text_view_layer_get_type
instance B.Types.BoxedEnum TextViewLayer
data TextExtendSelection =
TextExtendSelectionWord
| TextExtendSelectionLine
| AnotherTextExtendSelection Int
deriving (Int -> TextExtendSelection -> ShowS
[TextExtendSelection] -> ShowS
TextExtendSelection -> String
(Int -> TextExtendSelection -> ShowS)
-> (TextExtendSelection -> String)
-> ([TextExtendSelection] -> ShowS)
-> Show TextExtendSelection
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TextExtendSelection] -> ShowS
$cshowList :: [TextExtendSelection] -> ShowS
show :: TextExtendSelection -> String
$cshow :: TextExtendSelection -> String
showsPrec :: Int -> TextExtendSelection -> ShowS
$cshowsPrec :: Int -> TextExtendSelection -> ShowS
Show, TextExtendSelection -> TextExtendSelection -> Bool
(TextExtendSelection -> TextExtendSelection -> Bool)
-> (TextExtendSelection -> TextExtendSelection -> Bool)
-> Eq TextExtendSelection
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TextExtendSelection -> TextExtendSelection -> Bool
$c/= :: TextExtendSelection -> TextExtendSelection -> Bool
== :: TextExtendSelection -> TextExtendSelection -> Bool
$c== :: TextExtendSelection -> TextExtendSelection -> Bool
Eq)
instance P.Enum TextExtendSelection where
fromEnum :: TextExtendSelection -> Int
fromEnum TextExtendSelection
TextExtendSelectionWord = Int
0
fromEnum TextExtendSelection
TextExtendSelectionLine = Int
1
fromEnum (AnotherTextExtendSelection Int
k) = Int
k
toEnum :: Int -> TextExtendSelection
toEnum Int
0 = TextExtendSelection
TextExtendSelectionWord
toEnum Int
1 = TextExtendSelection
TextExtendSelectionLine
toEnum Int
k = Int -> TextExtendSelection
AnotherTextExtendSelection Int
k
instance P.Ord TextExtendSelection where
compare :: TextExtendSelection -> TextExtendSelection -> Ordering
compare TextExtendSelection
a TextExtendSelection
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (TextExtendSelection -> Int
forall a. Enum a => a -> Int
P.fromEnum TextExtendSelection
a) (TextExtendSelection -> Int
forall a. Enum a => a -> Int
P.fromEnum TextExtendSelection
b)
type instance O.ParentTypes TextExtendSelection = '[]
instance O.HasParentTypes TextExtendSelection
foreign import ccall "gtk_text_extend_selection_get_type" c_gtk_text_extend_selection_get_type ::
IO GType
instance B.Types.TypedObject TextExtendSelection where
glibType :: IO GType
glibType = IO GType
c_gtk_text_extend_selection_get_type
instance B.Types.BoxedEnum TextExtendSelection
data TextDirection =
TextDirectionNone
| TextDirectionLtr
| TextDirectionRtl
| AnotherTextDirection Int
deriving (Int -> TextDirection -> ShowS
[TextDirection] -> ShowS
TextDirection -> String
(Int -> TextDirection -> ShowS)
-> (TextDirection -> String)
-> ([TextDirection] -> ShowS)
-> Show TextDirection
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TextDirection] -> ShowS
$cshowList :: [TextDirection] -> ShowS
show :: TextDirection -> String
$cshow :: TextDirection -> String
showsPrec :: Int -> TextDirection -> ShowS
$cshowsPrec :: Int -> TextDirection -> ShowS
Show, TextDirection -> TextDirection -> Bool
(TextDirection -> TextDirection -> Bool)
-> (TextDirection -> TextDirection -> Bool) -> Eq TextDirection
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TextDirection -> TextDirection -> Bool
$c/= :: TextDirection -> TextDirection -> Bool
== :: TextDirection -> TextDirection -> Bool
$c== :: TextDirection -> TextDirection -> Bool
Eq)
instance P.Enum TextDirection where
fromEnum :: TextDirection -> Int
fromEnum TextDirection
TextDirectionNone = Int
0
fromEnum TextDirection
TextDirectionLtr = Int
1
fromEnum TextDirection
TextDirectionRtl = Int
2
fromEnum (AnotherTextDirection Int
k) = Int
k
toEnum :: Int -> TextDirection
toEnum Int
0 = TextDirection
TextDirectionNone
toEnum Int
1 = TextDirection
TextDirectionLtr
toEnum Int
2 = TextDirection
TextDirectionRtl
toEnum Int
k = Int -> TextDirection
AnotherTextDirection Int
k
instance P.Ord TextDirection where
compare :: TextDirection -> TextDirection -> Ordering
compare TextDirection
a TextDirection
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (TextDirection -> Int
forall a. Enum a => a -> Int
P.fromEnum TextDirection
a) (TextDirection -> Int
forall a. Enum a => a -> Int
P.fromEnum TextDirection
b)
type instance O.ParentTypes TextDirection = '[]
instance O.HasParentTypes TextDirection
foreign import ccall "gtk_text_direction_get_type" c_gtk_text_direction_get_type ::
IO GType
instance B.Types.TypedObject TextDirection where
glibType :: IO GType
glibType = IO GType
c_gtk_text_direction_get_type
instance B.Types.BoxedEnum TextDirection
data TextBufferTargetInfo =
TextBufferTargetInfoBufferContents
| TextBufferTargetInfoRichText
| TextBufferTargetInfoText
| AnotherTextBufferTargetInfo Int
deriving (Int -> TextBufferTargetInfo -> ShowS
[TextBufferTargetInfo] -> ShowS
TextBufferTargetInfo -> String
(Int -> TextBufferTargetInfo -> ShowS)
-> (TextBufferTargetInfo -> String)
-> ([TextBufferTargetInfo] -> ShowS)
-> Show TextBufferTargetInfo
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TextBufferTargetInfo] -> ShowS
$cshowList :: [TextBufferTargetInfo] -> ShowS
show :: TextBufferTargetInfo -> String
$cshow :: TextBufferTargetInfo -> String
showsPrec :: Int -> TextBufferTargetInfo -> ShowS
$cshowsPrec :: Int -> TextBufferTargetInfo -> ShowS
Show, TextBufferTargetInfo -> TextBufferTargetInfo -> Bool
(TextBufferTargetInfo -> TextBufferTargetInfo -> Bool)
-> (TextBufferTargetInfo -> TextBufferTargetInfo -> Bool)
-> Eq TextBufferTargetInfo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TextBufferTargetInfo -> TextBufferTargetInfo -> Bool
$c/= :: TextBufferTargetInfo -> TextBufferTargetInfo -> Bool
== :: TextBufferTargetInfo -> TextBufferTargetInfo -> Bool
$c== :: TextBufferTargetInfo -> TextBufferTargetInfo -> Bool
Eq)
instance P.Enum TextBufferTargetInfo where
fromEnum :: TextBufferTargetInfo -> Int
fromEnum TextBufferTargetInfo
TextBufferTargetInfoBufferContents = Int
-1
fromEnum TextBufferTargetInfo
TextBufferTargetInfoRichText = Int
-2
fromEnum TextBufferTargetInfo
TextBufferTargetInfoText = Int
-3
fromEnum (AnotherTextBufferTargetInfo Int
k) = Int
k
toEnum :: Int -> TextBufferTargetInfo
toEnum Int
-1 = TextBufferTargetInfo
TextBufferTargetInfoBufferContents
toEnum Int
-2 = TextBufferTargetInfo
TextBufferTargetInfoRichText
toEnum Int
-3 = TextBufferTargetInfo
TextBufferTargetInfoText
toEnum Int
k = Int -> TextBufferTargetInfo
AnotherTextBufferTargetInfo Int
k
instance P.Ord TextBufferTargetInfo where
compare :: TextBufferTargetInfo -> TextBufferTargetInfo -> Ordering
compare TextBufferTargetInfo
a TextBufferTargetInfo
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (TextBufferTargetInfo -> Int
forall a. Enum a => a -> Int
P.fromEnum TextBufferTargetInfo
a) (TextBufferTargetInfo -> Int
forall a. Enum a => a -> Int
P.fromEnum TextBufferTargetInfo
b)
type instance O.ParentTypes TextBufferTargetInfo = '[]
instance O.HasParentTypes TextBufferTargetInfo
foreign import ccall "gtk_text_buffer_target_info_get_type" c_gtk_text_buffer_target_info_get_type ::
IO GType
instance B.Types.TypedObject TextBufferTargetInfo where
glibType :: IO GType
glibType = IO GType
c_gtk_text_buffer_target_info_get_type
instance B.Types.BoxedEnum TextBufferTargetInfo
{-# DEPRECATED StateType ["(Since version 3.14)","All APIs that are using this enumeration have been deprecated"," in favor of alternatives using t'GI.Gtk.Flags.StateFlags'."] #-}
data StateType =
StateTypeNormal
| StateTypeActive
| StateTypePrelight
| StateTypeSelected
| StateTypeInsensitive
| StateTypeInconsistent
| StateTypeFocused
| AnotherStateType Int
deriving (Int -> StateType -> ShowS
[StateType] -> ShowS
StateType -> String
(Int -> StateType -> ShowS)
-> (StateType -> String)
-> ([StateType] -> ShowS)
-> Show StateType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StateType] -> ShowS
$cshowList :: [StateType] -> ShowS
show :: StateType -> String
$cshow :: StateType -> String
showsPrec :: Int -> StateType -> ShowS
$cshowsPrec :: Int -> StateType -> ShowS
Show, StateType -> StateType -> Bool
(StateType -> StateType -> Bool)
-> (StateType -> StateType -> Bool) -> Eq StateType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StateType -> StateType -> Bool
$c/= :: StateType -> StateType -> Bool
== :: StateType -> StateType -> Bool
$c== :: StateType -> StateType -> Bool
Eq)
instance P.Enum StateType where
fromEnum :: StateType -> Int
fromEnum StateType
StateTypeNormal = Int
0
fromEnum StateType
StateTypeActive = Int
1
fromEnum StateType
StateTypePrelight = Int
2
fromEnum StateType
StateTypeSelected = Int
3
fromEnum StateType
StateTypeInsensitive = Int
4
fromEnum StateType
StateTypeInconsistent = Int
5
fromEnum StateType
StateTypeFocused = Int
6
fromEnum (AnotherStateType Int
k) = Int
k
toEnum :: Int -> StateType
toEnum Int
0 = StateType
StateTypeNormal
toEnum Int
1 = StateType
StateTypeActive
toEnum Int
2 = StateType
StateTypePrelight
toEnum Int
3 = StateType
StateTypeSelected
toEnum Int
4 = StateType
StateTypeInsensitive
toEnum Int
5 = StateType
StateTypeInconsistent
toEnum Int
6 = StateType
StateTypeFocused
toEnum Int
k = Int -> StateType
AnotherStateType Int
k
instance P.Ord StateType where
compare :: StateType -> StateType -> Ordering
compare StateType
a StateType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (StateType -> Int
forall a. Enum a => a -> Int
P.fromEnum StateType
a) (StateType -> Int
forall a. Enum a => a -> Int
P.fromEnum StateType
b)
type instance O.ParentTypes StateType = '[]
instance O.HasParentTypes StateType
foreign import ccall "gtk_state_type_get_type" c_gtk_state_type_get_type ::
IO GType
instance B.Types.TypedObject StateType where
glibType :: IO GType
glibType = IO GType
c_gtk_state_type_get_type
instance B.Types.BoxedEnum StateType
data StackTransitionType =
StackTransitionTypeNone
| StackTransitionTypeCrossfade
| StackTransitionTypeSlideRight
| StackTransitionTypeSlideLeft
| StackTransitionTypeSlideUp
| StackTransitionTypeSlideDown
| StackTransitionTypeSlideLeftRight
| StackTransitionTypeSlideUpDown
| StackTransitionTypeOverUp
| StackTransitionTypeOverDown
| StackTransitionTypeOverLeft
| StackTransitionTypeOverRight
| StackTransitionTypeUnderUp
| StackTransitionTypeUnderDown
| StackTransitionTypeUnderLeft
| StackTransitionTypeUnderRight
| StackTransitionTypeOverUpDown
| StackTransitionTypeOverDownUp
| StackTransitionTypeOverLeftRight
| StackTransitionTypeOverRightLeft
| AnotherStackTransitionType Int
deriving (Int -> StackTransitionType -> ShowS
[StackTransitionType] -> ShowS
StackTransitionType -> String
(Int -> StackTransitionType -> ShowS)
-> (StackTransitionType -> String)
-> ([StackTransitionType] -> ShowS)
-> Show StackTransitionType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StackTransitionType] -> ShowS
$cshowList :: [StackTransitionType] -> ShowS
show :: StackTransitionType -> String
$cshow :: StackTransitionType -> String
showsPrec :: Int -> StackTransitionType -> ShowS
$cshowsPrec :: Int -> StackTransitionType -> ShowS
Show, StackTransitionType -> StackTransitionType -> Bool
(StackTransitionType -> StackTransitionType -> Bool)
-> (StackTransitionType -> StackTransitionType -> Bool)
-> Eq StackTransitionType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StackTransitionType -> StackTransitionType -> Bool
$c/= :: StackTransitionType -> StackTransitionType -> Bool
== :: StackTransitionType -> StackTransitionType -> Bool
$c== :: StackTransitionType -> StackTransitionType -> Bool
Eq)
instance P.Enum StackTransitionType where
fromEnum :: StackTransitionType -> Int
fromEnum StackTransitionType
StackTransitionTypeNone = Int
0
fromEnum StackTransitionType
StackTransitionTypeCrossfade = Int
1
fromEnum StackTransitionType
StackTransitionTypeSlideRight = Int
2
fromEnum StackTransitionType
StackTransitionTypeSlideLeft = Int
3
fromEnum StackTransitionType
StackTransitionTypeSlideUp = Int
4
fromEnum StackTransitionType
StackTransitionTypeSlideDown = Int
5
fromEnum StackTransitionType
StackTransitionTypeSlideLeftRight = Int
6
fromEnum StackTransitionType
StackTransitionTypeSlideUpDown = Int
7
fromEnum StackTransitionType
StackTransitionTypeOverUp = Int
8
fromEnum StackTransitionType
StackTransitionTypeOverDown = Int
9
fromEnum StackTransitionType
StackTransitionTypeOverLeft = Int
10
fromEnum StackTransitionType
StackTransitionTypeOverRight = Int
11
fromEnum StackTransitionType
StackTransitionTypeUnderUp = Int
12
fromEnum StackTransitionType
StackTransitionTypeUnderDown = Int
13
fromEnum StackTransitionType
StackTransitionTypeUnderLeft = Int
14
fromEnum StackTransitionType
StackTransitionTypeUnderRight = Int
15
fromEnum StackTransitionType
StackTransitionTypeOverUpDown = Int
16
fromEnum StackTransitionType
StackTransitionTypeOverDownUp = Int
17
fromEnum StackTransitionType
StackTransitionTypeOverLeftRight = Int
18
fromEnum StackTransitionType
StackTransitionTypeOverRightLeft = Int
19
fromEnum (AnotherStackTransitionType Int
k) = Int
k
toEnum :: Int -> StackTransitionType
toEnum Int
0 = StackTransitionType
StackTransitionTypeNone
toEnum Int
1 = StackTransitionType
StackTransitionTypeCrossfade
toEnum Int
2 = StackTransitionType
StackTransitionTypeSlideRight
toEnum Int
3 = StackTransitionType
StackTransitionTypeSlideLeft
toEnum Int
4 = StackTransitionType
StackTransitionTypeSlideUp
toEnum Int
5 = StackTransitionType
StackTransitionTypeSlideDown
toEnum Int
6 = StackTransitionType
StackTransitionTypeSlideLeftRight
toEnum Int
7 = StackTransitionType
StackTransitionTypeSlideUpDown
toEnum Int
8 = StackTransitionType
StackTransitionTypeOverUp
toEnum Int
9 = StackTransitionType
StackTransitionTypeOverDown
toEnum Int
10 = StackTransitionType
StackTransitionTypeOverLeft
toEnum Int
11 = StackTransitionType
StackTransitionTypeOverRight
toEnum Int
12 = StackTransitionType
StackTransitionTypeUnderUp
toEnum Int
13 = StackTransitionType
StackTransitionTypeUnderDown
toEnum Int
14 = StackTransitionType
StackTransitionTypeUnderLeft
toEnum Int
15 = StackTransitionType
StackTransitionTypeUnderRight
toEnum Int
16 = StackTransitionType
StackTransitionTypeOverUpDown
toEnum Int
17 = StackTransitionType
StackTransitionTypeOverDownUp
toEnum Int
18 = StackTransitionType
StackTransitionTypeOverLeftRight
toEnum Int
19 = StackTransitionType
StackTransitionTypeOverRightLeft
toEnum Int
k = Int -> StackTransitionType
AnotherStackTransitionType Int
k
instance P.Ord StackTransitionType where
compare :: StackTransitionType -> StackTransitionType -> Ordering
compare StackTransitionType
a StackTransitionType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (StackTransitionType -> Int
forall a. Enum a => a -> Int
P.fromEnum StackTransitionType
a) (StackTransitionType -> Int
forall a. Enum a => a -> Int
P.fromEnum StackTransitionType
b)
type instance O.ParentTypes StackTransitionType = '[]
instance O.HasParentTypes StackTransitionType
foreign import ccall "gtk_stack_transition_type_get_type" c_gtk_stack_transition_type_get_type ::
IO GType
instance B.Types.TypedObject StackTransitionType where
glibType :: IO GType
glibType = IO GType
c_gtk_stack_transition_type_get_type
instance B.Types.BoxedEnum StackTransitionType
data SpinType =
SpinTypeStepForward
| SpinTypeStepBackward
| SpinTypePageForward
| SpinTypePageBackward
| SpinTypeHome
| SpinTypeEnd
| SpinTypeUserDefined
| AnotherSpinType Int
deriving (Int -> SpinType -> ShowS
[SpinType] -> ShowS
SpinType -> String
(Int -> SpinType -> ShowS)
-> (SpinType -> String) -> ([SpinType] -> ShowS) -> Show SpinType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SpinType] -> ShowS
$cshowList :: [SpinType] -> ShowS
show :: SpinType -> String
$cshow :: SpinType -> String
showsPrec :: Int -> SpinType -> ShowS
$cshowsPrec :: Int -> SpinType -> ShowS
Show, SpinType -> SpinType -> Bool
(SpinType -> SpinType -> Bool)
-> (SpinType -> SpinType -> Bool) -> Eq SpinType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SpinType -> SpinType -> Bool
$c/= :: SpinType -> SpinType -> Bool
== :: SpinType -> SpinType -> Bool
$c== :: SpinType -> SpinType -> Bool
Eq)
instance P.Enum SpinType where
fromEnum :: SpinType -> Int
fromEnum SpinType
SpinTypeStepForward = Int
0
fromEnum SpinType
SpinTypeStepBackward = Int
1
fromEnum SpinType
SpinTypePageForward = Int
2
fromEnum SpinType
SpinTypePageBackward = Int
3
fromEnum SpinType
SpinTypeHome = Int
4
fromEnum SpinType
SpinTypeEnd = Int
5
fromEnum SpinType
SpinTypeUserDefined = Int
6
fromEnum (AnotherSpinType Int
k) = Int
k
toEnum :: Int -> SpinType
toEnum Int
0 = SpinType
SpinTypeStepForward
toEnum Int
1 = SpinType
SpinTypeStepBackward
toEnum Int
2 = SpinType
SpinTypePageForward
toEnum Int
3 = SpinType
SpinTypePageBackward
toEnum Int
4 = SpinType
SpinTypeHome
toEnum Int
5 = SpinType
SpinTypeEnd
toEnum Int
6 = SpinType
SpinTypeUserDefined
toEnum Int
k = Int -> SpinType
AnotherSpinType Int
k
instance P.Ord SpinType where
compare :: SpinType -> SpinType -> Ordering
compare SpinType
a SpinType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SpinType -> Int
forall a. Enum a => a -> Int
P.fromEnum SpinType
a) (SpinType -> Int
forall a. Enum a => a -> Int
P.fromEnum SpinType
b)
type instance O.ParentTypes SpinType = '[]
instance O.HasParentTypes SpinType
foreign import ccall "gtk_spin_type_get_type" c_gtk_spin_type_get_type ::
IO GType
instance B.Types.TypedObject SpinType where
glibType :: IO GType
glibType = IO GType
c_gtk_spin_type_get_type
instance B.Types.BoxedEnum SpinType
data SpinButtonUpdatePolicy =
SpinButtonUpdatePolicyAlways
| SpinButtonUpdatePolicyIfValid
| AnotherSpinButtonUpdatePolicy Int
deriving (Int -> SpinButtonUpdatePolicy -> ShowS
[SpinButtonUpdatePolicy] -> ShowS
SpinButtonUpdatePolicy -> String
(Int -> SpinButtonUpdatePolicy -> ShowS)
-> (SpinButtonUpdatePolicy -> String)
-> ([SpinButtonUpdatePolicy] -> ShowS)
-> Show SpinButtonUpdatePolicy
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SpinButtonUpdatePolicy] -> ShowS
$cshowList :: [SpinButtonUpdatePolicy] -> ShowS
show :: SpinButtonUpdatePolicy -> String
$cshow :: SpinButtonUpdatePolicy -> String
showsPrec :: Int -> SpinButtonUpdatePolicy -> ShowS
$cshowsPrec :: Int -> SpinButtonUpdatePolicy -> ShowS
Show, SpinButtonUpdatePolicy -> SpinButtonUpdatePolicy -> Bool
(SpinButtonUpdatePolicy -> SpinButtonUpdatePolicy -> Bool)
-> (SpinButtonUpdatePolicy -> SpinButtonUpdatePolicy -> Bool)
-> Eq SpinButtonUpdatePolicy
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SpinButtonUpdatePolicy -> SpinButtonUpdatePolicy -> Bool
$c/= :: SpinButtonUpdatePolicy -> SpinButtonUpdatePolicy -> Bool
== :: SpinButtonUpdatePolicy -> SpinButtonUpdatePolicy -> Bool
$c== :: SpinButtonUpdatePolicy -> SpinButtonUpdatePolicy -> Bool
Eq)
instance P.Enum SpinButtonUpdatePolicy where
fromEnum :: SpinButtonUpdatePolicy -> Int
fromEnum SpinButtonUpdatePolicy
SpinButtonUpdatePolicyAlways = Int
0
fromEnum SpinButtonUpdatePolicy
SpinButtonUpdatePolicyIfValid = Int
1
fromEnum (AnotherSpinButtonUpdatePolicy Int
k) = Int
k
toEnum :: Int -> SpinButtonUpdatePolicy
toEnum Int
0 = SpinButtonUpdatePolicy
SpinButtonUpdatePolicyAlways
toEnum Int
1 = SpinButtonUpdatePolicy
SpinButtonUpdatePolicyIfValid
toEnum Int
k = Int -> SpinButtonUpdatePolicy
AnotherSpinButtonUpdatePolicy Int
k
instance P.Ord SpinButtonUpdatePolicy where
compare :: SpinButtonUpdatePolicy -> SpinButtonUpdatePolicy -> Ordering
compare SpinButtonUpdatePolicy
a SpinButtonUpdatePolicy
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SpinButtonUpdatePolicy -> Int
forall a. Enum a => a -> Int
P.fromEnum SpinButtonUpdatePolicy
a) (SpinButtonUpdatePolicy -> Int
forall a. Enum a => a -> Int
P.fromEnum SpinButtonUpdatePolicy
b)
type instance O.ParentTypes SpinButtonUpdatePolicy = '[]
instance O.HasParentTypes SpinButtonUpdatePolicy
foreign import ccall "gtk_spin_button_update_policy_get_type" c_gtk_spin_button_update_policy_get_type ::
IO GType
instance B.Types.TypedObject SpinButtonUpdatePolicy where
glibType :: IO GType
glibType = IO GType
c_gtk_spin_button_update_policy_get_type
instance B.Types.BoxedEnum SpinButtonUpdatePolicy
data SortType =
SortTypeAscending
| SortTypeDescending
| AnotherSortType Int
deriving (Int -> SortType -> ShowS
[SortType] -> ShowS
SortType -> String
(Int -> SortType -> ShowS)
-> (SortType -> String) -> ([SortType] -> ShowS) -> Show SortType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SortType] -> ShowS
$cshowList :: [SortType] -> ShowS
show :: SortType -> String
$cshow :: SortType -> String
showsPrec :: Int -> SortType -> ShowS
$cshowsPrec :: Int -> SortType -> ShowS
Show, SortType -> SortType -> Bool
(SortType -> SortType -> Bool)
-> (SortType -> SortType -> Bool) -> Eq SortType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SortType -> SortType -> Bool
$c/= :: SortType -> SortType -> Bool
== :: SortType -> SortType -> Bool
$c== :: SortType -> SortType -> Bool
Eq)
instance P.Enum SortType where
fromEnum :: SortType -> Int
fromEnum SortType
SortTypeAscending = Int
0
fromEnum SortType
SortTypeDescending = Int
1
fromEnum (AnotherSortType Int
k) = Int
k
toEnum :: Int -> SortType
toEnum Int
0 = SortType
SortTypeAscending
toEnum Int
1 = SortType
SortTypeDescending
toEnum Int
k = Int -> SortType
AnotherSortType Int
k
instance P.Ord SortType where
compare :: SortType -> SortType -> Ordering
compare SortType
a SortType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SortType -> Int
forall a. Enum a => a -> Int
P.fromEnum SortType
a) (SortType -> Int
forall a. Enum a => a -> Int
P.fromEnum SortType
b)
type instance O.ParentTypes SortType = '[]
instance O.HasParentTypes SortType
foreign import ccall "gtk_sort_type_get_type" c_gtk_sort_type_get_type ::
IO GType
instance B.Types.TypedObject SortType where
glibType :: IO GType
glibType = IO GType
c_gtk_sort_type_get_type
instance B.Types.BoxedEnum SortType
data SizeRequestMode =
SizeRequestModeHeightForWidth
| SizeRequestModeWidthForHeight
| SizeRequestModeConstantSize
| AnotherSizeRequestMode Int
deriving (Int -> SizeRequestMode -> ShowS
[SizeRequestMode] -> ShowS
SizeRequestMode -> String
(Int -> SizeRequestMode -> ShowS)
-> (SizeRequestMode -> String)
-> ([SizeRequestMode] -> ShowS)
-> Show SizeRequestMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SizeRequestMode] -> ShowS
$cshowList :: [SizeRequestMode] -> ShowS
show :: SizeRequestMode -> String
$cshow :: SizeRequestMode -> String
showsPrec :: Int -> SizeRequestMode -> ShowS
$cshowsPrec :: Int -> SizeRequestMode -> ShowS
Show, SizeRequestMode -> SizeRequestMode -> Bool
(SizeRequestMode -> SizeRequestMode -> Bool)
-> (SizeRequestMode -> SizeRequestMode -> Bool)
-> Eq SizeRequestMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SizeRequestMode -> SizeRequestMode -> Bool
$c/= :: SizeRequestMode -> SizeRequestMode -> Bool
== :: SizeRequestMode -> SizeRequestMode -> Bool
$c== :: SizeRequestMode -> SizeRequestMode -> Bool
Eq)
instance P.Enum SizeRequestMode where
fromEnum :: SizeRequestMode -> Int
fromEnum SizeRequestMode
SizeRequestModeHeightForWidth = Int
0
fromEnum SizeRequestMode
SizeRequestModeWidthForHeight = Int
1
fromEnum SizeRequestMode
SizeRequestModeConstantSize = Int
2
fromEnum (AnotherSizeRequestMode Int
k) = Int
k
toEnum :: Int -> SizeRequestMode
toEnum Int
0 = SizeRequestMode
SizeRequestModeHeightForWidth
toEnum Int
1 = SizeRequestMode
SizeRequestModeWidthForHeight
toEnum Int
2 = SizeRequestMode
SizeRequestModeConstantSize
toEnum Int
k = Int -> SizeRequestMode
AnotherSizeRequestMode Int
k
instance P.Ord SizeRequestMode where
compare :: SizeRequestMode -> SizeRequestMode -> Ordering
compare SizeRequestMode
a SizeRequestMode
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SizeRequestMode -> Int
forall a. Enum a => a -> Int
P.fromEnum SizeRequestMode
a) (SizeRequestMode -> Int
forall a. Enum a => a -> Int
P.fromEnum SizeRequestMode
b)
type instance O.ParentTypes SizeRequestMode = '[]
instance O.HasParentTypes SizeRequestMode
foreign import ccall "gtk_size_request_mode_get_type" c_gtk_size_request_mode_get_type ::
IO GType
instance B.Types.TypedObject SizeRequestMode where
glibType :: IO GType
glibType = IO GType
c_gtk_size_request_mode_get_type
instance B.Types.BoxedEnum SizeRequestMode
data SizeGroupMode =
SizeGroupModeNone
| SizeGroupModeHorizontal
| SizeGroupModeVertical
| SizeGroupModeBoth
| AnotherSizeGroupMode Int
deriving (Int -> SizeGroupMode -> ShowS
[SizeGroupMode] -> ShowS
SizeGroupMode -> String
(Int -> SizeGroupMode -> ShowS)
-> (SizeGroupMode -> String)
-> ([SizeGroupMode] -> ShowS)
-> Show SizeGroupMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SizeGroupMode] -> ShowS
$cshowList :: [SizeGroupMode] -> ShowS
show :: SizeGroupMode -> String
$cshow :: SizeGroupMode -> String
showsPrec :: Int -> SizeGroupMode -> ShowS
$cshowsPrec :: Int -> SizeGroupMode -> ShowS
Show, SizeGroupMode -> SizeGroupMode -> Bool
(SizeGroupMode -> SizeGroupMode -> Bool)
-> (SizeGroupMode -> SizeGroupMode -> Bool) -> Eq SizeGroupMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SizeGroupMode -> SizeGroupMode -> Bool
$c/= :: SizeGroupMode -> SizeGroupMode -> Bool
== :: SizeGroupMode -> SizeGroupMode -> Bool
$c== :: SizeGroupMode -> SizeGroupMode -> Bool
Eq)
instance P.Enum SizeGroupMode where
fromEnum :: SizeGroupMode -> Int
fromEnum SizeGroupMode
SizeGroupModeNone = Int
0
fromEnum SizeGroupMode
SizeGroupModeHorizontal = Int
1
fromEnum SizeGroupMode
SizeGroupModeVertical = Int
2
fromEnum SizeGroupMode
SizeGroupModeBoth = Int
3
fromEnum (AnotherSizeGroupMode Int
k) = Int
k
toEnum :: Int -> SizeGroupMode
toEnum Int
0 = SizeGroupMode
SizeGroupModeNone
toEnum Int
1 = SizeGroupMode
SizeGroupModeHorizontal
toEnum Int
2 = SizeGroupMode
SizeGroupModeVertical
toEnum Int
3 = SizeGroupMode
SizeGroupModeBoth
toEnum Int
k = Int -> SizeGroupMode
AnotherSizeGroupMode Int
k
instance P.Ord SizeGroupMode where
compare :: SizeGroupMode -> SizeGroupMode -> Ordering
compare SizeGroupMode
a SizeGroupMode
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SizeGroupMode -> Int
forall a. Enum a => a -> Int
P.fromEnum SizeGroupMode
a) (SizeGroupMode -> Int
forall a. Enum a => a -> Int
P.fromEnum SizeGroupMode
b)
type instance O.ParentTypes SizeGroupMode = '[]
instance O.HasParentTypes SizeGroupMode
foreign import ccall "gtk_size_group_mode_get_type" c_gtk_size_group_mode_get_type ::
IO GType
instance B.Types.TypedObject SizeGroupMode where
glibType :: IO GType
glibType = IO GType
c_gtk_size_group_mode_get_type
instance B.Types.BoxedEnum SizeGroupMode
data ShortcutType =
ShortcutTypeAccelerator
| ShortcutTypeGesturePinch
| ShortcutTypeGestureStretch
| ShortcutTypeGestureRotateClockwise
| ShortcutTypeGestureRotateCounterclockwise
| ShortcutTypeGestureTwoFingerSwipeLeft
| ShortcutTypeGestureTwoFingerSwipeRight
| ShortcutTypeGesture
| AnotherShortcutType Int
deriving (Int -> ShortcutType -> ShowS
[ShortcutType] -> ShowS
ShortcutType -> String
(Int -> ShortcutType -> ShowS)
-> (ShortcutType -> String)
-> ([ShortcutType] -> ShowS)
-> Show ShortcutType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ShortcutType] -> ShowS
$cshowList :: [ShortcutType] -> ShowS
show :: ShortcutType -> String
$cshow :: ShortcutType -> String
showsPrec :: Int -> ShortcutType -> ShowS
$cshowsPrec :: Int -> ShortcutType -> ShowS
Show, ShortcutType -> ShortcutType -> Bool
(ShortcutType -> ShortcutType -> Bool)
-> (ShortcutType -> ShortcutType -> Bool) -> Eq ShortcutType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ShortcutType -> ShortcutType -> Bool
$c/= :: ShortcutType -> ShortcutType -> Bool
== :: ShortcutType -> ShortcutType -> Bool
$c== :: ShortcutType -> ShortcutType -> Bool
Eq)
instance P.Enum ShortcutType where
fromEnum :: ShortcutType -> Int
fromEnum ShortcutType
ShortcutTypeAccelerator = Int
0
fromEnum ShortcutType
ShortcutTypeGesturePinch = Int
1
fromEnum ShortcutType
ShortcutTypeGestureStretch = Int
2
fromEnum ShortcutType
ShortcutTypeGestureRotateClockwise = Int
3
fromEnum ShortcutType
ShortcutTypeGestureRotateCounterclockwise = Int
4
fromEnum ShortcutType
ShortcutTypeGestureTwoFingerSwipeLeft = Int
5
fromEnum ShortcutType
ShortcutTypeGestureTwoFingerSwipeRight = Int
6
fromEnum ShortcutType
ShortcutTypeGesture = Int
7
fromEnum (AnotherShortcutType Int
k) = Int
k
toEnum :: Int -> ShortcutType
toEnum Int
0 = ShortcutType
ShortcutTypeAccelerator
toEnum Int
1 = ShortcutType
ShortcutTypeGesturePinch
toEnum Int
2 = ShortcutType
ShortcutTypeGestureStretch
toEnum Int
3 = ShortcutType
ShortcutTypeGestureRotateClockwise
toEnum Int
4 = ShortcutType
ShortcutTypeGestureRotateCounterclockwise
toEnum Int
5 = ShortcutType
ShortcutTypeGestureTwoFingerSwipeLeft
toEnum Int
6 = ShortcutType
ShortcutTypeGestureTwoFingerSwipeRight
toEnum Int
7 = ShortcutType
ShortcutTypeGesture
toEnum Int
k = Int -> ShortcutType
AnotherShortcutType Int
k
instance P.Ord ShortcutType where
compare :: ShortcutType -> ShortcutType -> Ordering
compare ShortcutType
a ShortcutType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ShortcutType -> Int
forall a. Enum a => a -> Int
P.fromEnum ShortcutType
a) (ShortcutType -> Int
forall a. Enum a => a -> Int
P.fromEnum ShortcutType
b)
type instance O.ParentTypes ShortcutType = '[]
instance O.HasParentTypes ShortcutType
foreign import ccall "gtk_shortcut_type_get_type" c_gtk_shortcut_type_get_type ::
IO GType
instance B.Types.TypedObject ShortcutType where
glibType :: IO GType
glibType = IO GType
c_gtk_shortcut_type_get_type
instance B.Types.BoxedEnum ShortcutType
data ShadowType =
ShadowTypeNone
| ShadowTypeIn
| ShadowTypeOut
| ShadowTypeEtchedIn
| ShadowTypeEtchedOut
| AnotherShadowType Int
deriving (Int -> ShadowType -> ShowS
[ShadowType] -> ShowS
ShadowType -> String
(Int -> ShadowType -> ShowS)
-> (ShadowType -> String)
-> ([ShadowType] -> ShowS)
-> Show ShadowType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ShadowType] -> ShowS
$cshowList :: [ShadowType] -> ShowS
show :: ShadowType -> String
$cshow :: ShadowType -> String
showsPrec :: Int -> ShadowType -> ShowS
$cshowsPrec :: Int -> ShadowType -> ShowS
Show, ShadowType -> ShadowType -> Bool
(ShadowType -> ShadowType -> Bool)
-> (ShadowType -> ShadowType -> Bool) -> Eq ShadowType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ShadowType -> ShadowType -> Bool
$c/= :: ShadowType -> ShadowType -> Bool
== :: ShadowType -> ShadowType -> Bool
$c== :: ShadowType -> ShadowType -> Bool
Eq)
instance P.Enum ShadowType where
fromEnum :: ShadowType -> Int
fromEnum ShadowType
ShadowTypeNone = Int
0
fromEnum ShadowType
ShadowTypeIn = Int
1
fromEnum ShadowType
ShadowTypeOut = Int
2
fromEnum ShadowType
ShadowTypeEtchedIn = Int
3
fromEnum ShadowType
ShadowTypeEtchedOut = Int
4
fromEnum (AnotherShadowType Int
k) = Int
k
toEnum :: Int -> ShadowType
toEnum Int
0 = ShadowType
ShadowTypeNone
toEnum Int
1 = ShadowType
ShadowTypeIn
toEnum Int
2 = ShadowType
ShadowTypeOut
toEnum Int
3 = ShadowType
ShadowTypeEtchedIn
toEnum Int
4 = ShadowType
ShadowTypeEtchedOut
toEnum Int
k = Int -> ShadowType
AnotherShadowType Int
k
instance P.Ord ShadowType where
compare :: ShadowType -> ShadowType -> Ordering
compare ShadowType
a ShadowType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ShadowType -> Int
forall a. Enum a => a -> Int
P.fromEnum ShadowType
a) (ShadowType -> Int
forall a. Enum a => a -> Int
P.fromEnum ShadowType
b)
type instance O.ParentTypes ShadowType = '[]
instance O.HasParentTypes ShadowType
foreign import ccall "gtk_shadow_type_get_type" c_gtk_shadow_type_get_type ::
IO GType
instance B.Types.TypedObject ShadowType where
glibType :: IO GType
glibType = IO GType
c_gtk_shadow_type_get_type
instance B.Types.BoxedEnum ShadowType
data SensitivityType =
SensitivityTypeAuto
| SensitivityTypeOn
| SensitivityTypeOff
| AnotherSensitivityType Int
deriving (Int -> SensitivityType -> ShowS
[SensitivityType] -> ShowS
SensitivityType -> String
(Int -> SensitivityType -> ShowS)
-> (SensitivityType -> String)
-> ([SensitivityType] -> ShowS)
-> Show SensitivityType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SensitivityType] -> ShowS
$cshowList :: [SensitivityType] -> ShowS
show :: SensitivityType -> String
$cshow :: SensitivityType -> String
showsPrec :: Int -> SensitivityType -> ShowS
$cshowsPrec :: Int -> SensitivityType -> ShowS
Show, SensitivityType -> SensitivityType -> Bool
(SensitivityType -> SensitivityType -> Bool)
-> (SensitivityType -> SensitivityType -> Bool)
-> Eq SensitivityType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SensitivityType -> SensitivityType -> Bool
$c/= :: SensitivityType -> SensitivityType -> Bool
== :: SensitivityType -> SensitivityType -> Bool
$c== :: SensitivityType -> SensitivityType -> Bool
Eq)
instance P.Enum SensitivityType where
fromEnum :: SensitivityType -> Int
fromEnum SensitivityType
SensitivityTypeAuto = Int
0
fromEnum SensitivityType
SensitivityTypeOn = Int
1
fromEnum SensitivityType
SensitivityTypeOff = Int
2
fromEnum (AnotherSensitivityType Int
k) = Int
k
toEnum :: Int -> SensitivityType
toEnum Int
0 = SensitivityType
SensitivityTypeAuto
toEnum Int
1 = SensitivityType
SensitivityTypeOn
toEnum Int
2 = SensitivityType
SensitivityTypeOff
toEnum Int
k = Int -> SensitivityType
AnotherSensitivityType Int
k
instance P.Ord SensitivityType where
compare :: SensitivityType -> SensitivityType -> Ordering
compare SensitivityType
a SensitivityType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SensitivityType -> Int
forall a. Enum a => a -> Int
P.fromEnum SensitivityType
a) (SensitivityType -> Int
forall a. Enum a => a -> Int
P.fromEnum SensitivityType
b)
type instance O.ParentTypes SensitivityType = '[]
instance O.HasParentTypes SensitivityType
foreign import ccall "gtk_sensitivity_type_get_type" c_gtk_sensitivity_type_get_type ::
IO GType
instance B.Types.TypedObject SensitivityType where
glibType :: IO GType
glibType = IO GType
c_gtk_sensitivity_type_get_type
instance B.Types.BoxedEnum SensitivityType
data SelectionMode =
SelectionModeNone
| SelectionModeSingle
| SelectionModeBrowse
| SelectionModeMultiple
| AnotherSelectionMode Int
deriving (Int -> SelectionMode -> ShowS
[SelectionMode] -> ShowS
SelectionMode -> String
(Int -> SelectionMode -> ShowS)
-> (SelectionMode -> String)
-> ([SelectionMode] -> ShowS)
-> Show SelectionMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SelectionMode] -> ShowS
$cshowList :: [SelectionMode] -> ShowS
show :: SelectionMode -> String
$cshow :: SelectionMode -> String
showsPrec :: Int -> SelectionMode -> ShowS
$cshowsPrec :: Int -> SelectionMode -> ShowS
Show, SelectionMode -> SelectionMode -> Bool
(SelectionMode -> SelectionMode -> Bool)
-> (SelectionMode -> SelectionMode -> Bool) -> Eq SelectionMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SelectionMode -> SelectionMode -> Bool
$c/= :: SelectionMode -> SelectionMode -> Bool
== :: SelectionMode -> SelectionMode -> Bool
$c== :: SelectionMode -> SelectionMode -> Bool
Eq)
instance P.Enum SelectionMode where
fromEnum :: SelectionMode -> Int
fromEnum SelectionMode
SelectionModeNone = Int
0
fromEnum SelectionMode
SelectionModeSingle = Int
1
fromEnum SelectionMode
SelectionModeBrowse = Int
2
fromEnum SelectionMode
SelectionModeMultiple = Int
3
fromEnum (AnotherSelectionMode Int
k) = Int
k
toEnum :: Int -> SelectionMode
toEnum Int
0 = SelectionMode
SelectionModeNone
toEnum Int
1 = SelectionMode
SelectionModeSingle
toEnum Int
2 = SelectionMode
SelectionModeBrowse
toEnum Int
3 = SelectionMode
SelectionModeMultiple
toEnum Int
k = Int -> SelectionMode
AnotherSelectionMode Int
k
instance P.Ord SelectionMode where
compare :: SelectionMode -> SelectionMode -> Ordering
compare SelectionMode
a SelectionMode
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SelectionMode -> Int
forall a. Enum a => a -> Int
P.fromEnum SelectionMode
a) (SelectionMode -> Int
forall a. Enum a => a -> Int
P.fromEnum SelectionMode
b)
type instance O.ParentTypes SelectionMode = '[]
instance O.HasParentTypes SelectionMode
foreign import ccall "gtk_selection_mode_get_type" c_gtk_selection_mode_get_type ::
IO GType
instance B.Types.TypedObject SelectionMode where
glibType :: IO GType
glibType = IO GType
c_gtk_selection_mode_get_type
instance B.Types.BoxedEnum SelectionMode
data ScrollablePolicy =
ScrollablePolicyMinimum
| ScrollablePolicyNatural
| AnotherScrollablePolicy Int
deriving (Int -> ScrollablePolicy -> ShowS
[ScrollablePolicy] -> ShowS
ScrollablePolicy -> String
(Int -> ScrollablePolicy -> ShowS)
-> (ScrollablePolicy -> String)
-> ([ScrollablePolicy] -> ShowS)
-> Show ScrollablePolicy
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ScrollablePolicy] -> ShowS
$cshowList :: [ScrollablePolicy] -> ShowS
show :: ScrollablePolicy -> String
$cshow :: ScrollablePolicy -> String
showsPrec :: Int -> ScrollablePolicy -> ShowS
$cshowsPrec :: Int -> ScrollablePolicy -> ShowS
Show, ScrollablePolicy -> ScrollablePolicy -> Bool
(ScrollablePolicy -> ScrollablePolicy -> Bool)
-> (ScrollablePolicy -> ScrollablePolicy -> Bool)
-> Eq ScrollablePolicy
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ScrollablePolicy -> ScrollablePolicy -> Bool
$c/= :: ScrollablePolicy -> ScrollablePolicy -> Bool
== :: ScrollablePolicy -> ScrollablePolicy -> Bool
$c== :: ScrollablePolicy -> ScrollablePolicy -> Bool
Eq)
instance P.Enum ScrollablePolicy where
fromEnum :: ScrollablePolicy -> Int
fromEnum ScrollablePolicy
ScrollablePolicyMinimum = Int
0
fromEnum ScrollablePolicy
ScrollablePolicyNatural = Int
1
fromEnum (AnotherScrollablePolicy Int
k) = Int
k
toEnum :: Int -> ScrollablePolicy
toEnum Int
0 = ScrollablePolicy
ScrollablePolicyMinimum
toEnum Int
1 = ScrollablePolicy
ScrollablePolicyNatural
toEnum Int
k = Int -> ScrollablePolicy
AnotherScrollablePolicy Int
k
instance P.Ord ScrollablePolicy where
compare :: ScrollablePolicy -> ScrollablePolicy -> Ordering
compare ScrollablePolicy
a ScrollablePolicy
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ScrollablePolicy -> Int
forall a. Enum a => a -> Int
P.fromEnum ScrollablePolicy
a) (ScrollablePolicy -> Int
forall a. Enum a => a -> Int
P.fromEnum ScrollablePolicy
b)
type instance O.ParentTypes ScrollablePolicy = '[]
instance O.HasParentTypes ScrollablePolicy
foreign import ccall "gtk_scrollable_policy_get_type" c_gtk_scrollable_policy_get_type ::
IO GType
instance B.Types.TypedObject ScrollablePolicy where
glibType :: IO GType
glibType = IO GType
c_gtk_scrollable_policy_get_type
instance B.Types.BoxedEnum ScrollablePolicy
data ScrollType =
ScrollTypeNone
| ScrollTypeJump
| ScrollTypeStepBackward
| ScrollTypeStepForward
| ScrollTypePageBackward
| ScrollTypePageForward
| ScrollTypeStepUp
| ScrollTypeStepDown
| ScrollTypePageUp
| ScrollTypePageDown
| ScrollTypeStepLeft
| ScrollTypeStepRight
| ScrollTypePageLeft
|
| ScrollTypeStart
| ScrollTypeEnd
| AnotherScrollType Int
deriving (Int -> ScrollType -> ShowS
[ScrollType] -> ShowS
ScrollType -> String
(Int -> ScrollType -> ShowS)
-> (ScrollType -> String)
-> ([ScrollType] -> ShowS)
-> Show ScrollType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ScrollType] -> ShowS
$cshowList :: [ScrollType] -> ShowS
show :: ScrollType -> String
$cshow :: ScrollType -> String
showsPrec :: Int -> ScrollType -> ShowS
$cshowsPrec :: Int -> ScrollType -> ShowS
Show, ScrollType -> ScrollType -> Bool
(ScrollType -> ScrollType -> Bool)
-> (ScrollType -> ScrollType -> Bool) -> Eq ScrollType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ScrollType -> ScrollType -> Bool
$c/= :: ScrollType -> ScrollType -> Bool
== :: ScrollType -> ScrollType -> Bool
$c== :: ScrollType -> ScrollType -> Bool
Eq)
instance P.Enum ScrollType where
fromEnum :: ScrollType -> Int
fromEnum ScrollType
ScrollTypeNone = Int
0
fromEnum ScrollType
ScrollTypeJump = Int
1
fromEnum ScrollType
ScrollTypeStepBackward = Int
2
fromEnum ScrollType
ScrollTypeStepForward = Int
3
fromEnum ScrollType
ScrollTypePageBackward = Int
4
fromEnum ScrollType
ScrollTypePageForward = Int
5
fromEnum ScrollType
ScrollTypeStepUp = Int
6
fromEnum ScrollType
ScrollTypeStepDown = Int
7
fromEnum ScrollType
ScrollTypePageUp = Int
8
fromEnum ScrollType
ScrollTypePageDown = Int
9
fromEnum ScrollType
ScrollTypeStepLeft = Int
10
fromEnum ScrollType
ScrollTypeStepRight = Int
11
fromEnum ScrollType
ScrollTypePageLeft = Int
12
fromEnum ScrollType
ScrollTypePageRight = Int
13
fromEnum ScrollType
ScrollTypeStart = Int
14
fromEnum ScrollType
ScrollTypeEnd = Int
15
fromEnum (AnotherScrollType Int
k) = Int
k
toEnum :: Int -> ScrollType
toEnum Int
0 = ScrollType
ScrollTypeNone
toEnum Int
1 = ScrollType
ScrollTypeJump
toEnum Int
2 = ScrollType
ScrollTypeStepBackward
toEnum Int
3 = ScrollType
ScrollTypeStepForward
toEnum Int
4 = ScrollType
ScrollTypePageBackward
toEnum Int
5 = ScrollType
ScrollTypePageForward
toEnum Int
6 = ScrollType
ScrollTypeStepUp
toEnum Int
7 = ScrollType
ScrollTypeStepDown
toEnum Int
8 = ScrollType
ScrollTypePageUp
toEnum Int
9 = ScrollType
ScrollTypePageDown
toEnum Int
10 = ScrollType
ScrollTypeStepLeft
toEnum Int
11 = ScrollType
ScrollTypeStepRight
toEnum Int
12 = ScrollType
ScrollTypePageLeft
toEnum Int
13 = ScrollType
ScrollTypePageRight
toEnum Int
14 = ScrollType
ScrollTypeStart
toEnum Int
15 = ScrollType
ScrollTypeEnd
toEnum Int
k = Int -> ScrollType
AnotherScrollType Int
k
instance P.Ord ScrollType where
compare :: ScrollType -> ScrollType -> Ordering
compare ScrollType
a ScrollType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ScrollType -> Int
forall a. Enum a => a -> Int
P.fromEnum ScrollType
a) (ScrollType -> Int
forall a. Enum a => a -> Int
P.fromEnum ScrollType
b)
type instance O.ParentTypes ScrollType = '[]
instance O.HasParentTypes ScrollType
foreign import ccall "gtk_scroll_type_get_type" c_gtk_scroll_type_get_type ::
IO GType
instance B.Types.TypedObject ScrollType where
glibType :: IO GType
glibType = IO GType
c_gtk_scroll_type_get_type
instance B.Types.BoxedEnum ScrollType
data ScrollStep =
ScrollStepSteps
| ScrollStepPages
| ScrollStepEnds
| ScrollStepHorizontalSteps
| ScrollStepHorizontalPages
| ScrollStepHorizontalEnds
| AnotherScrollStep Int
deriving (Int -> ScrollStep -> ShowS
[ScrollStep] -> ShowS
ScrollStep -> String
(Int -> ScrollStep -> ShowS)
-> (ScrollStep -> String)
-> ([ScrollStep] -> ShowS)
-> Show ScrollStep
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ScrollStep] -> ShowS
$cshowList :: [ScrollStep] -> ShowS
show :: ScrollStep -> String
$cshow :: ScrollStep -> String
showsPrec :: Int -> ScrollStep -> ShowS
$cshowsPrec :: Int -> ScrollStep -> ShowS
Show, ScrollStep -> ScrollStep -> Bool
(ScrollStep -> ScrollStep -> Bool)
-> (ScrollStep -> ScrollStep -> Bool) -> Eq ScrollStep
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ScrollStep -> ScrollStep -> Bool
$c/= :: ScrollStep -> ScrollStep -> Bool
== :: ScrollStep -> ScrollStep -> Bool
$c== :: ScrollStep -> ScrollStep -> Bool
Eq)
instance P.Enum ScrollStep where
fromEnum :: ScrollStep -> Int
fromEnum ScrollStep
ScrollStepSteps = Int
0
fromEnum ScrollStep
ScrollStepPages = Int
1
fromEnum ScrollStep
ScrollStepEnds = Int
2
fromEnum ScrollStep
ScrollStepHorizontalSteps = Int
3
fromEnum ScrollStep
ScrollStepHorizontalPages = Int
4
fromEnum ScrollStep
ScrollStepHorizontalEnds = Int
5
fromEnum (AnotherScrollStep Int
k) = Int
k
toEnum :: Int -> ScrollStep
toEnum Int
0 = ScrollStep
ScrollStepSteps
toEnum Int
1 = ScrollStep
ScrollStepPages
toEnum Int
2 = ScrollStep
ScrollStepEnds
toEnum Int
3 = ScrollStep
ScrollStepHorizontalSteps
toEnum Int
4 = ScrollStep
ScrollStepHorizontalPages
toEnum Int
5 = ScrollStep
ScrollStepHorizontalEnds
toEnum Int
k = Int -> ScrollStep
AnotherScrollStep Int
k
instance P.Ord ScrollStep where
compare :: ScrollStep -> ScrollStep -> Ordering
compare ScrollStep
a ScrollStep
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ScrollStep -> Int
forall a. Enum a => a -> Int
P.fromEnum ScrollStep
a) (ScrollStep -> Int
forall a. Enum a => a -> Int
P.fromEnum ScrollStep
b)
type instance O.ParentTypes ScrollStep = '[]
instance O.HasParentTypes ScrollStep
foreign import ccall "gtk_scroll_step_get_type" c_gtk_scroll_step_get_type ::
IO GType
instance B.Types.TypedObject ScrollStep where
glibType :: IO GType
glibType = IO GType
c_gtk_scroll_step_get_type
instance B.Types.BoxedEnum ScrollStep
data RevealerTransitionType =
RevealerTransitionTypeNone
| RevealerTransitionTypeCrossfade
| RevealerTransitionTypeSlideRight
| RevealerTransitionTypeSlideLeft
| RevealerTransitionTypeSlideUp
| RevealerTransitionTypeSlideDown
| AnotherRevealerTransitionType Int
deriving (Int -> RevealerTransitionType -> ShowS
[RevealerTransitionType] -> ShowS
RevealerTransitionType -> String
(Int -> RevealerTransitionType -> ShowS)
-> (RevealerTransitionType -> String)
-> ([RevealerTransitionType] -> ShowS)
-> Show RevealerTransitionType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RevealerTransitionType] -> ShowS
$cshowList :: [RevealerTransitionType] -> ShowS
show :: RevealerTransitionType -> String
$cshow :: RevealerTransitionType -> String
showsPrec :: Int -> RevealerTransitionType -> ShowS
$cshowsPrec :: Int -> RevealerTransitionType -> ShowS
Show, RevealerTransitionType -> RevealerTransitionType -> Bool
(RevealerTransitionType -> RevealerTransitionType -> Bool)
-> (RevealerTransitionType -> RevealerTransitionType -> Bool)
-> Eq RevealerTransitionType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RevealerTransitionType -> RevealerTransitionType -> Bool
$c/= :: RevealerTransitionType -> RevealerTransitionType -> Bool
== :: RevealerTransitionType -> RevealerTransitionType -> Bool
$c== :: RevealerTransitionType -> RevealerTransitionType -> Bool
Eq)
instance P.Enum RevealerTransitionType where
fromEnum :: RevealerTransitionType -> Int
fromEnum RevealerTransitionType
RevealerTransitionTypeNone = Int
0
fromEnum RevealerTransitionType
RevealerTransitionTypeCrossfade = Int
1
fromEnum RevealerTransitionType
RevealerTransitionTypeSlideRight = Int
2
fromEnum RevealerTransitionType
RevealerTransitionTypeSlideLeft = Int
3
fromEnum RevealerTransitionType
RevealerTransitionTypeSlideUp = Int
4
fromEnum RevealerTransitionType
RevealerTransitionTypeSlideDown = Int
5
fromEnum (AnotherRevealerTransitionType Int
k) = Int
k
toEnum :: Int -> RevealerTransitionType
toEnum Int
0 = RevealerTransitionType
RevealerTransitionTypeNone
toEnum Int
1 = RevealerTransitionType
RevealerTransitionTypeCrossfade
toEnum Int
2 = RevealerTransitionType
RevealerTransitionTypeSlideRight
toEnum Int
3 = RevealerTransitionType
RevealerTransitionTypeSlideLeft
toEnum Int
4 = RevealerTransitionType
RevealerTransitionTypeSlideUp
toEnum Int
5 = RevealerTransitionType
RevealerTransitionTypeSlideDown
toEnum Int
k = Int -> RevealerTransitionType
AnotherRevealerTransitionType Int
k
instance P.Ord RevealerTransitionType where
compare :: RevealerTransitionType -> RevealerTransitionType -> Ordering
compare RevealerTransitionType
a RevealerTransitionType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (RevealerTransitionType -> Int
forall a. Enum a => a -> Int
P.fromEnum RevealerTransitionType
a) (RevealerTransitionType -> Int
forall a. Enum a => a -> Int
P.fromEnum RevealerTransitionType
b)
type instance O.ParentTypes RevealerTransitionType = '[]
instance O.HasParentTypes RevealerTransitionType
foreign import ccall "gtk_revealer_transition_type_get_type" c_gtk_revealer_transition_type_get_type ::
IO GType
instance B.Types.TypedObject RevealerTransitionType where
glibType :: IO GType
glibType = IO GType
c_gtk_revealer_transition_type_get_type
instance B.Types.BoxedEnum RevealerTransitionType
data ResponseType =
ResponseTypeNone
| ResponseTypeReject
| ResponseTypeAccept
| ResponseTypeDeleteEvent
| ResponseTypeOk
| ResponseTypeCancel
| ResponseTypeClose
| ResponseTypeYes
| ResponseTypeNo
| ResponseTypeApply
| ResponseTypeHelp
| AnotherResponseType Int
deriving (Int -> ResponseType -> ShowS
[ResponseType] -> ShowS
ResponseType -> String
(Int -> ResponseType -> ShowS)
-> (ResponseType -> String)
-> ([ResponseType] -> ShowS)
-> Show ResponseType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ResponseType] -> ShowS
$cshowList :: [ResponseType] -> ShowS
show :: ResponseType -> String
$cshow :: ResponseType -> String
showsPrec :: Int -> ResponseType -> ShowS
$cshowsPrec :: Int -> ResponseType -> ShowS
Show, ResponseType -> ResponseType -> Bool
(ResponseType -> ResponseType -> Bool)
-> (ResponseType -> ResponseType -> Bool) -> Eq ResponseType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ResponseType -> ResponseType -> Bool
$c/= :: ResponseType -> ResponseType -> Bool
== :: ResponseType -> ResponseType -> Bool
$c== :: ResponseType -> ResponseType -> Bool
Eq)
instance P.Enum ResponseType where
fromEnum :: ResponseType -> Int
fromEnum ResponseType
ResponseTypeNone = Int
-1
fromEnum ResponseType
ResponseTypeReject = Int
-2
fromEnum ResponseType
ResponseTypeAccept = Int
-3
fromEnum ResponseType
ResponseTypeDeleteEvent = Int
-4
fromEnum ResponseType
ResponseTypeOk = Int
-5
fromEnum ResponseType
ResponseTypeCancel = Int
-6
fromEnum ResponseType
ResponseTypeClose = Int
-7
fromEnum ResponseType
ResponseTypeYes = Int
-8
fromEnum ResponseType
ResponseTypeNo = Int
-9
fromEnum ResponseType
ResponseTypeApply = Int
-10
fromEnum ResponseType
ResponseTypeHelp = Int
-11
fromEnum (AnotherResponseType Int
k) = Int
k
toEnum :: Int -> ResponseType
toEnum Int
-1 = ResponseType
ResponseTypeNone
toEnum Int
-2 = ResponseType
ResponseTypeReject
toEnum Int
-3 = ResponseType
ResponseTypeAccept
toEnum Int
-4 = ResponseType
ResponseTypeDeleteEvent
toEnum Int
-5 = ResponseType
ResponseTypeOk
toEnum Int
-6 = ResponseType
ResponseTypeCancel
toEnum Int
-7 = ResponseType
ResponseTypeClose
toEnum Int
-8 = ResponseType
ResponseTypeYes
toEnum Int
-9 = ResponseType
ResponseTypeNo
toEnum Int
-10 = ResponseType
ResponseTypeApply
toEnum Int
-11 = ResponseType
ResponseTypeHelp
toEnum Int
k = Int -> ResponseType
AnotherResponseType Int
k
instance P.Ord ResponseType where
compare :: ResponseType -> ResponseType -> Ordering
compare ResponseType
a ResponseType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ResponseType -> Int
forall a. Enum a => a -> Int
P.fromEnum ResponseType
a) (ResponseType -> Int
forall a. Enum a => a -> Int
P.fromEnum ResponseType
b)
type instance O.ParentTypes ResponseType = '[]
instance O.HasParentTypes ResponseType
foreign import ccall "gtk_response_type_get_type" c_gtk_response_type_get_type ::
IO GType
instance B.Types.TypedObject ResponseType where
glibType :: IO GType
glibType = IO GType
c_gtk_response_type_get_type
instance B.Types.BoxedEnum ResponseType
data ResizeMode =
ResizeModeParent
| ResizeModeQueue
| ResizeModeImmediate
| AnotherResizeMode Int
deriving (Int -> ResizeMode -> ShowS
[ResizeMode] -> ShowS
ResizeMode -> String
(Int -> ResizeMode -> ShowS)
-> (ResizeMode -> String)
-> ([ResizeMode] -> ShowS)
-> Show ResizeMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ResizeMode] -> ShowS
$cshowList :: [ResizeMode] -> ShowS
show :: ResizeMode -> String
$cshow :: ResizeMode -> String
showsPrec :: Int -> ResizeMode -> ShowS
$cshowsPrec :: Int -> ResizeMode -> ShowS
Show, ResizeMode -> ResizeMode -> Bool
(ResizeMode -> ResizeMode -> Bool)
-> (ResizeMode -> ResizeMode -> Bool) -> Eq ResizeMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ResizeMode -> ResizeMode -> Bool
$c/= :: ResizeMode -> ResizeMode -> Bool
== :: ResizeMode -> ResizeMode -> Bool
$c== :: ResizeMode -> ResizeMode -> Bool
Eq)
instance P.Enum ResizeMode where
fromEnum :: ResizeMode -> Int
fromEnum ResizeMode
ResizeModeParent = Int
0
fromEnum ResizeMode
ResizeModeQueue = Int
1
fromEnum ResizeMode
ResizeModeImmediate = Int
2
fromEnum (AnotherResizeMode Int
k) = Int
k
toEnum :: Int -> ResizeMode
toEnum Int
0 = ResizeMode
ResizeModeParent
toEnum Int
1 = ResizeMode
ResizeModeQueue
toEnum Int
2 = ResizeMode
ResizeModeImmediate
toEnum Int
k = Int -> ResizeMode
AnotherResizeMode Int
k
instance P.Ord ResizeMode where
compare :: ResizeMode -> ResizeMode -> Ordering
compare ResizeMode
a ResizeMode
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ResizeMode -> Int
forall a. Enum a => a -> Int
P.fromEnum ResizeMode
a) (ResizeMode -> Int
forall a. Enum a => a -> Int
P.fromEnum ResizeMode
b)
type instance O.ParentTypes ResizeMode = '[]
instance O.HasParentTypes ResizeMode
foreign import ccall "gtk_resize_mode_get_type" c_gtk_resize_mode_get_type ::
IO GType
instance B.Types.TypedObject ResizeMode where
glibType :: IO GType
glibType = IO GType
c_gtk_resize_mode_get_type
instance B.Types.BoxedEnum ResizeMode
data ReliefStyle =
ReliefStyleNormal
| ReliefStyleHalf
| ReliefStyleNone
| AnotherReliefStyle Int
deriving (Int -> ReliefStyle -> ShowS
[ReliefStyle] -> ShowS
ReliefStyle -> String
(Int -> ReliefStyle -> ShowS)
-> (ReliefStyle -> String)
-> ([ReliefStyle] -> ShowS)
-> Show ReliefStyle
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ReliefStyle] -> ShowS
$cshowList :: [ReliefStyle] -> ShowS
show :: ReliefStyle -> String
$cshow :: ReliefStyle -> String
showsPrec :: Int -> ReliefStyle -> ShowS
$cshowsPrec :: Int -> ReliefStyle -> ShowS
Show, ReliefStyle -> ReliefStyle -> Bool
(ReliefStyle -> ReliefStyle -> Bool)
-> (ReliefStyle -> ReliefStyle -> Bool) -> Eq ReliefStyle
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ReliefStyle -> ReliefStyle -> Bool
$c/= :: ReliefStyle -> ReliefStyle -> Bool
== :: ReliefStyle -> ReliefStyle -> Bool
$c== :: ReliefStyle -> ReliefStyle -> Bool
Eq)
instance P.Enum ReliefStyle where
fromEnum :: ReliefStyle -> Int
fromEnum ReliefStyle
ReliefStyleNormal = Int
0
fromEnum ReliefStyle
ReliefStyleHalf = Int
1
fromEnum ReliefStyle
ReliefStyleNone = Int
2
fromEnum (AnotherReliefStyle Int
k) = Int
k
toEnum :: Int -> ReliefStyle
toEnum Int
0 = ReliefStyle
ReliefStyleNormal
toEnum Int
1 = ReliefStyle
ReliefStyleHalf
toEnum Int
2 = ReliefStyle
ReliefStyleNone
toEnum Int
k = Int -> ReliefStyle
AnotherReliefStyle Int
k
instance P.Ord ReliefStyle where
compare :: ReliefStyle -> ReliefStyle -> Ordering
compare ReliefStyle
a ReliefStyle
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ReliefStyle -> Int
forall a. Enum a => a -> Int
P.fromEnum ReliefStyle
a) (ReliefStyle -> Int
forall a. Enum a => a -> Int
P.fromEnum ReliefStyle
b)
type instance O.ParentTypes ReliefStyle = '[]
instance O.HasParentTypes ReliefStyle
foreign import ccall "gtk_relief_style_get_type" c_gtk_relief_style_get_type ::
IO GType
instance B.Types.TypedObject ReliefStyle where
glibType :: IO GType
glibType = IO GType
c_gtk_relief_style_get_type
instance B.Types.BoxedEnum ReliefStyle
data RecentSortType =
RecentSortTypeNone
| RecentSortTypeMru
| RecentSortTypeLru
| RecentSortTypeCustom
| AnotherRecentSortType Int
deriving (Int -> RecentSortType -> ShowS
[RecentSortType] -> ShowS
RecentSortType -> String
(Int -> RecentSortType -> ShowS)
-> (RecentSortType -> String)
-> ([RecentSortType] -> ShowS)
-> Show RecentSortType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RecentSortType] -> ShowS
$cshowList :: [RecentSortType] -> ShowS
show :: RecentSortType -> String
$cshow :: RecentSortType -> String
showsPrec :: Int -> RecentSortType -> ShowS
$cshowsPrec :: Int -> RecentSortType -> ShowS
Show, RecentSortType -> RecentSortType -> Bool
(RecentSortType -> RecentSortType -> Bool)
-> (RecentSortType -> RecentSortType -> Bool) -> Eq RecentSortType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RecentSortType -> RecentSortType -> Bool
$c/= :: RecentSortType -> RecentSortType -> Bool
== :: RecentSortType -> RecentSortType -> Bool
$c== :: RecentSortType -> RecentSortType -> Bool
Eq)
instance P.Enum RecentSortType where
fromEnum :: RecentSortType -> Int
fromEnum RecentSortType
RecentSortTypeNone = Int
0
fromEnum RecentSortType
RecentSortTypeMru = Int
1
fromEnum RecentSortType
RecentSortTypeLru = Int
2
fromEnum RecentSortType
RecentSortTypeCustom = Int
3
fromEnum (AnotherRecentSortType Int
k) = Int
k
toEnum :: Int -> RecentSortType
toEnum Int
0 = RecentSortType
RecentSortTypeNone
toEnum Int
1 = RecentSortType
RecentSortTypeMru
toEnum Int
2 = RecentSortType
RecentSortTypeLru
toEnum Int
3 = RecentSortType
RecentSortTypeCustom
toEnum Int
k = Int -> RecentSortType
AnotherRecentSortType Int
k
instance P.Ord RecentSortType where
compare :: RecentSortType -> RecentSortType -> Ordering
compare RecentSortType
a RecentSortType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (RecentSortType -> Int
forall a. Enum a => a -> Int
P.fromEnum RecentSortType
a) (RecentSortType -> Int
forall a. Enum a => a -> Int
P.fromEnum RecentSortType
b)
type instance O.ParentTypes RecentSortType = '[]
instance O.HasParentTypes RecentSortType
foreign import ccall "gtk_recent_sort_type_get_type" c_gtk_recent_sort_type_get_type ::
IO GType
instance B.Types.TypedObject RecentSortType where
glibType :: IO GType
glibType = IO GType
c_gtk_recent_sort_type_get_type
instance B.Types.BoxedEnum RecentSortType
data RecentManagerError =
RecentManagerErrorNotFound
| RecentManagerErrorInvalidUri
| RecentManagerErrorInvalidEncoding
| RecentManagerErrorNotRegistered
| RecentManagerErrorRead
| RecentManagerErrorWrite
| RecentManagerErrorUnknown
| AnotherRecentManagerError Int
deriving (Int -> RecentManagerError -> ShowS
[RecentManagerError] -> ShowS
RecentManagerError -> String
(Int -> RecentManagerError -> ShowS)
-> (RecentManagerError -> String)
-> ([RecentManagerError] -> ShowS)
-> Show RecentManagerError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RecentManagerError] -> ShowS
$cshowList :: [RecentManagerError] -> ShowS
show :: RecentManagerError -> String
$cshow :: RecentManagerError -> String
showsPrec :: Int -> RecentManagerError -> ShowS
$cshowsPrec :: Int -> RecentManagerError -> ShowS
Show, RecentManagerError -> RecentManagerError -> Bool
(RecentManagerError -> RecentManagerError -> Bool)
-> (RecentManagerError -> RecentManagerError -> Bool)
-> Eq RecentManagerError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RecentManagerError -> RecentManagerError -> Bool
$c/= :: RecentManagerError -> RecentManagerError -> Bool
== :: RecentManagerError -> RecentManagerError -> Bool
$c== :: RecentManagerError -> RecentManagerError -> Bool
Eq)
instance P.Enum RecentManagerError where
fromEnum :: RecentManagerError -> Int
fromEnum RecentManagerError
RecentManagerErrorNotFound = Int
0
fromEnum RecentManagerError
RecentManagerErrorInvalidUri = Int
1
fromEnum RecentManagerError
RecentManagerErrorInvalidEncoding = Int
2
fromEnum RecentManagerError
RecentManagerErrorNotRegistered = Int
3
fromEnum RecentManagerError
RecentManagerErrorRead = Int
4
fromEnum RecentManagerError
RecentManagerErrorWrite = Int
5
fromEnum RecentManagerError
RecentManagerErrorUnknown = Int
6
fromEnum (AnotherRecentManagerError Int
k) = Int
k
toEnum :: Int -> RecentManagerError
toEnum Int
0 = RecentManagerError
RecentManagerErrorNotFound
toEnum Int
1 = RecentManagerError
RecentManagerErrorInvalidUri
toEnum Int
2 = RecentManagerError
RecentManagerErrorInvalidEncoding
toEnum Int
3 = RecentManagerError
RecentManagerErrorNotRegistered
toEnum Int
4 = RecentManagerError
RecentManagerErrorRead
toEnum Int
5 = RecentManagerError
RecentManagerErrorWrite
toEnum Int
6 = RecentManagerError
RecentManagerErrorUnknown
toEnum Int
k = Int -> RecentManagerError
AnotherRecentManagerError Int
k
instance P.Ord RecentManagerError where
compare :: RecentManagerError -> RecentManagerError -> Ordering
compare RecentManagerError
a RecentManagerError
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (RecentManagerError -> Int
forall a. Enum a => a -> Int
P.fromEnum RecentManagerError
a) (RecentManagerError -> Int
forall a. Enum a => a -> Int
P.fromEnum RecentManagerError
b)
instance GErrorClass RecentManagerError where
gerrorClassDomain :: RecentManagerError -> Text
gerrorClassDomain RecentManagerError
_ = Text
"gtk-recent-manager-error-quark"
catchRecentManagerError ::
IO a ->
(RecentManagerError -> GErrorMessage -> IO a) ->
IO a
catchRecentManagerError :: forall a. IO a -> (RecentManagerError -> Text -> IO a) -> IO a
catchRecentManagerError = IO a -> (RecentManagerError -> Text -> IO a) -> IO a
forall err a.
GErrorClass err =>
IO a -> (err -> Text -> IO a) -> IO a
catchGErrorJustDomain
handleRecentManagerError ::
(RecentManagerError -> GErrorMessage -> IO a) ->
IO a ->
IO a
handleRecentManagerError :: forall a. (RecentManagerError -> Text -> IO a) -> IO a -> IO a
handleRecentManagerError = (RecentManagerError -> Text -> IO a) -> IO a -> IO a
forall err a.
GErrorClass err =>
(err -> Text -> IO a) -> IO a -> IO a
handleGErrorJustDomain
type instance O.ParentTypes RecentManagerError = '[]
instance O.HasParentTypes RecentManagerError
foreign import ccall "gtk_recent_manager_error_get_type" c_gtk_recent_manager_error_get_type ::
IO GType
instance B.Types.TypedObject RecentManagerError where
glibType :: IO GType
glibType = IO GType
c_gtk_recent_manager_error_get_type
instance B.Types.BoxedEnum RecentManagerError
data RecentChooserError =
RecentChooserErrorNotFound
| RecentChooserErrorInvalidUri
| AnotherRecentChooserError Int
deriving (Int -> RecentChooserError -> ShowS
[RecentChooserError] -> ShowS
RecentChooserError -> String
(Int -> RecentChooserError -> ShowS)
-> (RecentChooserError -> String)
-> ([RecentChooserError] -> ShowS)
-> Show RecentChooserError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RecentChooserError] -> ShowS
$cshowList :: [RecentChooserError] -> ShowS
show :: RecentChooserError -> String
$cshow :: RecentChooserError -> String
showsPrec :: Int -> RecentChooserError -> ShowS
$cshowsPrec :: Int -> RecentChooserError -> ShowS
Show, RecentChooserError -> RecentChooserError -> Bool
(RecentChooserError -> RecentChooserError -> Bool)
-> (RecentChooserError -> RecentChooserError -> Bool)
-> Eq RecentChooserError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RecentChooserError -> RecentChooserError -> Bool
$c/= :: RecentChooserError -> RecentChooserError -> Bool
== :: RecentChooserError -> RecentChooserError -> Bool
$c== :: RecentChooserError -> RecentChooserError -> Bool
Eq)
instance P.Enum RecentChooserError where
fromEnum :: RecentChooserError -> Int
fromEnum RecentChooserError
RecentChooserErrorNotFound = Int
0
fromEnum RecentChooserError
RecentChooserErrorInvalidUri = Int
1
fromEnum (AnotherRecentChooserError Int
k) = Int
k
toEnum :: Int -> RecentChooserError
toEnum Int
0 = RecentChooserError
RecentChooserErrorNotFound
toEnum Int
1 = RecentChooserError
RecentChooserErrorInvalidUri
toEnum Int
k = Int -> RecentChooserError
AnotherRecentChooserError Int
k
instance P.Ord RecentChooserError where
compare :: RecentChooserError -> RecentChooserError -> Ordering
compare RecentChooserError
a RecentChooserError
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (RecentChooserError -> Int
forall a. Enum a => a -> Int
P.fromEnum RecentChooserError
a) (RecentChooserError -> Int
forall a. Enum a => a -> Int
P.fromEnum RecentChooserError
b)
instance GErrorClass RecentChooserError where
gerrorClassDomain :: RecentChooserError -> Text
gerrorClassDomain RecentChooserError
_ = Text
"gtk-recent-chooser-error-quark"
catchRecentChooserError ::
IO a ->
(RecentChooserError -> GErrorMessage -> IO a) ->
IO a
catchRecentChooserError :: forall a. IO a -> (RecentChooserError -> Text -> IO a) -> IO a
catchRecentChooserError = IO a -> (RecentChooserError -> Text -> IO a) -> IO a
forall err a.
GErrorClass err =>
IO a -> (err -> Text -> IO a) -> IO a
catchGErrorJustDomain
handleRecentChooserError ::
(RecentChooserError -> GErrorMessage -> IO a) ->
IO a ->
IO a
handleRecentChooserError :: forall a. (RecentChooserError -> Text -> IO a) -> IO a -> IO a
handleRecentChooserError = (RecentChooserError -> Text -> IO a) -> IO a -> IO a
forall err a.
GErrorClass err =>
(err -> Text -> IO a) -> IO a -> IO a
handleGErrorJustDomain
type instance O.ParentTypes RecentChooserError = '[]
instance O.HasParentTypes RecentChooserError
foreign import ccall "gtk_recent_chooser_error_get_type" c_gtk_recent_chooser_error_get_type ::
IO GType
instance B.Types.TypedObject RecentChooserError where
glibType :: IO GType
glibType = IO GType
c_gtk_recent_chooser_error_get_type
instance B.Types.BoxedEnum RecentChooserError
{-# DEPRECATED RcTokenType ["(Since version 3.0)","Use t'GI.Gtk.Objects.CssProvider.CssProvider' instead."] #-}
data RcTokenType =
RcTokenTypeInvalid
| RcTokenTypeInclude
| RcTokenTypeNormal
| RcTokenTypeActive
| RcTokenTypePrelight
| RcTokenTypeSelected
| RcTokenTypeInsensitive
| RcTokenTypeFg
| RcTokenTypeBg
| RcTokenTypeText
| RcTokenTypeBase
| RcTokenTypeXthickness
| RcTokenTypeYthickness
| RcTokenTypeFont
| RcTokenTypeFontset
| RcTokenTypeFontName
| RcTokenTypeBgPixmap
| RcTokenTypePixmapPath
| RcTokenTypeStyle
| RcTokenTypeBinding
| RcTokenTypeBind
| RcTokenTypeWidget
| RcTokenTypeWidgetClass
| RcTokenTypeClass
| RcTokenTypeLowest
| RcTokenTypeGtk
| RcTokenTypeApplication
| RcTokenTypeTheme
| RcTokenTypeRc
| RcTokenTypeHighest
| RcTokenTypeEngine
| RcTokenTypeModulePath
| RcTokenTypeImModulePath
| RcTokenTypeImModuleFile
| RcTokenTypeStock
| RcTokenTypeLtr
| RcTokenTypeRtl
| RcTokenTypeColor
| RcTokenTypeUnbind
| RcTokenTypeLast
| AnotherRcTokenType Int
deriving (Int -> RcTokenType -> ShowS
[RcTokenType] -> ShowS
RcTokenType -> String
(Int -> RcTokenType -> ShowS)
-> (RcTokenType -> String)
-> ([RcTokenType] -> ShowS)
-> Show RcTokenType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RcTokenType] -> ShowS
$cshowList :: [RcTokenType] -> ShowS
show :: RcTokenType -> String
$cshow :: RcTokenType -> String
showsPrec :: Int -> RcTokenType -> ShowS
$cshowsPrec :: Int -> RcTokenType -> ShowS
Show, RcTokenType -> RcTokenType -> Bool
(RcTokenType -> RcTokenType -> Bool)
-> (RcTokenType -> RcTokenType -> Bool) -> Eq RcTokenType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RcTokenType -> RcTokenType -> Bool
$c/= :: RcTokenType -> RcTokenType -> Bool
== :: RcTokenType -> RcTokenType -> Bool
$c== :: RcTokenType -> RcTokenType -> Bool
Eq)
instance P.Enum RcTokenType where
fromEnum :: RcTokenType -> Int
fromEnum RcTokenType
RcTokenTypeInvalid = Int
270
fromEnum RcTokenType
RcTokenTypeInclude = Int
271
fromEnum RcTokenType
RcTokenTypeNormal = Int
272
fromEnum RcTokenType
RcTokenTypeActive = Int
273
fromEnum RcTokenType
RcTokenTypePrelight = Int
274
fromEnum RcTokenType
RcTokenTypeSelected = Int
275
fromEnum RcTokenType
RcTokenTypeInsensitive = Int
276
fromEnum RcTokenType
RcTokenTypeFg = Int
277
fromEnum RcTokenType
RcTokenTypeBg = Int
278
fromEnum RcTokenType
RcTokenTypeText = Int
279
fromEnum RcTokenType
RcTokenTypeBase = Int
280
fromEnum RcTokenType
RcTokenTypeXthickness = Int
281
fromEnum RcTokenType
RcTokenTypeYthickness = Int
282
fromEnum RcTokenType
RcTokenTypeFont = Int
283
fromEnum RcTokenType
RcTokenTypeFontset = Int
284
fromEnum RcTokenType
RcTokenTypeFontName = Int
285
fromEnum RcTokenType
RcTokenTypeBgPixmap = Int
286
fromEnum RcTokenType
RcTokenTypePixmapPath = Int
287
fromEnum RcTokenType
RcTokenTypeStyle = Int
288
fromEnum RcTokenType
RcTokenTypeBinding = Int
289
fromEnum RcTokenType
RcTokenTypeBind = Int
290
fromEnum RcTokenType
RcTokenTypeWidget = Int
291
fromEnum RcTokenType
RcTokenTypeWidgetClass = Int
292
fromEnum RcTokenType
RcTokenTypeClass = Int
293
fromEnum RcTokenType
RcTokenTypeLowest = Int
294
fromEnum RcTokenType
RcTokenTypeGtk = Int
295
fromEnum RcTokenType
RcTokenTypeApplication = Int
296
fromEnum RcTokenType
RcTokenTypeTheme = Int
297
fromEnum RcTokenType
RcTokenTypeRc = Int
298
fromEnum RcTokenType
RcTokenTypeHighest = Int
299
fromEnum RcTokenType
RcTokenTypeEngine = Int
300
fromEnum RcTokenType
RcTokenTypeModulePath = Int
301
fromEnum RcTokenType
RcTokenTypeImModulePath = Int
302
fromEnum RcTokenType
RcTokenTypeImModuleFile = Int
303
fromEnum RcTokenType
RcTokenTypeStock = Int
304
fromEnum RcTokenType
RcTokenTypeLtr = Int
305
fromEnum RcTokenType
RcTokenTypeRtl = Int
306
fromEnum RcTokenType
RcTokenTypeColor = Int
307
fromEnum RcTokenType
RcTokenTypeUnbind = Int
308
fromEnum RcTokenType
RcTokenTypeLast = Int
309
fromEnum (AnotherRcTokenType Int
k) = Int
k
toEnum :: Int -> RcTokenType
toEnum Int
270 = RcTokenType
RcTokenTypeInvalid
toEnum Int
271 = RcTokenType
RcTokenTypeInclude
toEnum Int
272 = RcTokenType
RcTokenTypeNormal
toEnum Int
273 = RcTokenType
RcTokenTypeActive
toEnum Int
274 = RcTokenType
RcTokenTypePrelight
toEnum Int
275 = RcTokenType
RcTokenTypeSelected
toEnum Int
276 = RcTokenType
RcTokenTypeInsensitive
toEnum Int
277 = RcTokenType
RcTokenTypeFg
toEnum Int
278 = RcTokenType
RcTokenTypeBg
toEnum Int
279 = RcTokenType
RcTokenTypeText
toEnum Int
280 = RcTokenType
RcTokenTypeBase
toEnum Int
281 = RcTokenType
RcTokenTypeXthickness
toEnum Int
282 = RcTokenType
RcTokenTypeYthickness
toEnum Int
283 = RcTokenType
RcTokenTypeFont
toEnum Int
284 = RcTokenType
RcTokenTypeFontset
toEnum Int
285 = RcTokenType
RcTokenTypeFontName
toEnum Int
286 = RcTokenType
RcTokenTypeBgPixmap
toEnum Int
287 = RcTokenType
RcTokenTypePixmapPath
toEnum Int
288 = RcTokenType
RcTokenTypeStyle
toEnum Int
289 = RcTokenType
RcTokenTypeBinding
toEnum Int
290 = RcTokenType
RcTokenTypeBind
toEnum Int
291 = RcTokenType
RcTokenTypeWidget
toEnum Int
292 = RcTokenType
RcTokenTypeWidgetClass
toEnum Int
293 = RcTokenType
RcTokenTypeClass
toEnum Int
294 = RcTokenType
RcTokenTypeLowest
toEnum Int
295 = RcTokenType
RcTokenTypeGtk
toEnum Int
296 = RcTokenType
RcTokenTypeApplication
toEnum Int
297 = RcTokenType
RcTokenTypeTheme
toEnum Int
298 = RcTokenType
RcTokenTypeRc
toEnum Int
299 = RcTokenType
RcTokenTypeHighest
toEnum Int
300 = RcTokenType
RcTokenTypeEngine
toEnum Int
301 = RcTokenType
RcTokenTypeModulePath
toEnum Int
302 = RcTokenType
RcTokenTypeImModulePath
toEnum Int
303 = RcTokenType
RcTokenTypeImModuleFile
toEnum Int
304 = RcTokenType
RcTokenTypeStock
toEnum Int
305 = RcTokenType
RcTokenTypeLtr
toEnum Int
306 = RcTokenType
RcTokenTypeRtl
toEnum Int
307 = RcTokenType
RcTokenTypeColor
toEnum Int
308 = RcTokenType
RcTokenTypeUnbind
toEnum Int
309 = RcTokenType
RcTokenTypeLast
toEnum Int
k = Int -> RcTokenType
AnotherRcTokenType Int
k
instance P.Ord RcTokenType where
compare :: RcTokenType -> RcTokenType -> Ordering
compare RcTokenType
a RcTokenType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (RcTokenType -> Int
forall a. Enum a => a -> Int
P.fromEnum RcTokenType
a) (RcTokenType -> Int
forall a. Enum a => a -> Int
P.fromEnum RcTokenType
b)
type instance O.ParentTypes RcTokenType = '[]
instance O.HasParentTypes RcTokenType
foreign import ccall "gtk_rc_token_type_get_type" c_gtk_rc_token_type_get_type ::
IO GType
instance B.Types.TypedObject RcTokenType where
glibType :: IO GType
glibType = IO GType
c_gtk_rc_token_type_get_type
instance B.Types.BoxedEnum RcTokenType
data PropagationPhase =
PropagationPhaseNone
| PropagationPhaseCapture
| PropagationPhaseBubble
| PropagationPhaseTarget
| AnotherPropagationPhase Int
deriving (Int -> PropagationPhase -> ShowS
[PropagationPhase] -> ShowS
PropagationPhase -> String
(Int -> PropagationPhase -> ShowS)
-> (PropagationPhase -> String)
-> ([PropagationPhase] -> ShowS)
-> Show PropagationPhase
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PropagationPhase] -> ShowS
$cshowList :: [PropagationPhase] -> ShowS
show :: PropagationPhase -> String
$cshow :: PropagationPhase -> String
showsPrec :: Int -> PropagationPhase -> ShowS
$cshowsPrec :: Int -> PropagationPhase -> ShowS
Show, PropagationPhase -> PropagationPhase -> Bool
(PropagationPhase -> PropagationPhase -> Bool)
-> (PropagationPhase -> PropagationPhase -> Bool)
-> Eq PropagationPhase
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PropagationPhase -> PropagationPhase -> Bool
$c/= :: PropagationPhase -> PropagationPhase -> Bool
== :: PropagationPhase -> PropagationPhase -> Bool
$c== :: PropagationPhase -> PropagationPhase -> Bool
Eq)
instance P.Enum PropagationPhase where
fromEnum :: PropagationPhase -> Int
fromEnum PropagationPhase
PropagationPhaseNone = Int
0
fromEnum PropagationPhase
PropagationPhaseCapture = Int
1
fromEnum PropagationPhase
PropagationPhaseBubble = Int
2
fromEnum PropagationPhase
PropagationPhaseTarget = Int
3
fromEnum (AnotherPropagationPhase Int
k) = Int
k
toEnum :: Int -> PropagationPhase
toEnum Int
0 = PropagationPhase
PropagationPhaseNone
toEnum Int
1 = PropagationPhase
PropagationPhaseCapture
toEnum Int
2 = PropagationPhase
PropagationPhaseBubble
toEnum Int
3 = PropagationPhase
PropagationPhaseTarget
toEnum Int
k = Int -> PropagationPhase
AnotherPropagationPhase Int
k
instance P.Ord PropagationPhase where
compare :: PropagationPhase -> PropagationPhase -> Ordering
compare PropagationPhase
a PropagationPhase
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PropagationPhase -> Int
forall a. Enum a => a -> Int
P.fromEnum PropagationPhase
a) (PropagationPhase -> Int
forall a. Enum a => a -> Int
P.fromEnum PropagationPhase
b)
type instance O.ParentTypes PropagationPhase = '[]
instance O.HasParentTypes PropagationPhase
foreign import ccall "gtk_propagation_phase_get_type" c_gtk_propagation_phase_get_type ::
IO GType
instance B.Types.TypedObject PropagationPhase where
glibType :: IO GType
glibType = IO GType
c_gtk_propagation_phase_get_type
instance B.Types.BoxedEnum PropagationPhase
data PrintStatus =
PrintStatusInitial
| PrintStatusPreparing
| PrintStatusGeneratingData
| PrintStatusSendingData
| PrintStatusPending
| PrintStatusPendingIssue
| PrintStatusPrinting
| PrintStatusFinished
| PrintStatusFinishedAborted
| AnotherPrintStatus Int
deriving (Int -> PrintStatus -> ShowS
[PrintStatus] -> ShowS
PrintStatus -> String
(Int -> PrintStatus -> ShowS)
-> (PrintStatus -> String)
-> ([PrintStatus] -> ShowS)
-> Show PrintStatus
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PrintStatus] -> ShowS
$cshowList :: [PrintStatus] -> ShowS
show :: PrintStatus -> String
$cshow :: PrintStatus -> String
showsPrec :: Int -> PrintStatus -> ShowS
$cshowsPrec :: Int -> PrintStatus -> ShowS
Show, PrintStatus -> PrintStatus -> Bool
(PrintStatus -> PrintStatus -> Bool)
-> (PrintStatus -> PrintStatus -> Bool) -> Eq PrintStatus
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PrintStatus -> PrintStatus -> Bool
$c/= :: PrintStatus -> PrintStatus -> Bool
== :: PrintStatus -> PrintStatus -> Bool
$c== :: PrintStatus -> PrintStatus -> Bool
Eq)
instance P.Enum PrintStatus where
fromEnum :: PrintStatus -> Int
fromEnum PrintStatus
PrintStatusInitial = Int
0
fromEnum PrintStatus
PrintStatusPreparing = Int
1
fromEnum PrintStatus
PrintStatusGeneratingData = Int
2
fromEnum PrintStatus
PrintStatusSendingData = Int
3
fromEnum PrintStatus
PrintStatusPending = Int
4
fromEnum PrintStatus
PrintStatusPendingIssue = Int
5
fromEnum PrintStatus
PrintStatusPrinting = Int
6
fromEnum PrintStatus
PrintStatusFinished = Int
7
fromEnum PrintStatus
PrintStatusFinishedAborted = Int
8
fromEnum (AnotherPrintStatus Int
k) = Int
k
toEnum :: Int -> PrintStatus
toEnum Int
0 = PrintStatus
PrintStatusInitial
toEnum Int
1 = PrintStatus
PrintStatusPreparing
toEnum Int
2 = PrintStatus
PrintStatusGeneratingData
toEnum Int
3 = PrintStatus
PrintStatusSendingData
toEnum Int
4 = PrintStatus
PrintStatusPending
toEnum Int
5 = PrintStatus
PrintStatusPendingIssue
toEnum Int
6 = PrintStatus
PrintStatusPrinting
toEnum Int
7 = PrintStatus
PrintStatusFinished
toEnum Int
8 = PrintStatus
PrintStatusFinishedAborted
toEnum Int
k = Int -> PrintStatus
AnotherPrintStatus Int
k
instance P.Ord PrintStatus where
compare :: PrintStatus -> PrintStatus -> Ordering
compare PrintStatus
a PrintStatus
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PrintStatus -> Int
forall a. Enum a => a -> Int
P.fromEnum PrintStatus
a) (PrintStatus -> Int
forall a. Enum a => a -> Int
P.fromEnum PrintStatus
b)
type instance O.ParentTypes PrintStatus = '[]
instance O.HasParentTypes PrintStatus
foreign import ccall "gtk_print_status_get_type" c_gtk_print_status_get_type ::
IO GType
instance B.Types.TypedObject PrintStatus where
glibType :: IO GType
glibType = IO GType
c_gtk_print_status_get_type
instance B.Types.BoxedEnum PrintStatus
data PrintQuality =
PrintQualityLow
| PrintQualityNormal
| PrintQualityHigh
| PrintQualityDraft
| AnotherPrintQuality Int
deriving (Int -> PrintQuality -> ShowS
[PrintQuality] -> ShowS
PrintQuality -> String
(Int -> PrintQuality -> ShowS)
-> (PrintQuality -> String)
-> ([PrintQuality] -> ShowS)
-> Show PrintQuality
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PrintQuality] -> ShowS
$cshowList :: [PrintQuality] -> ShowS
show :: PrintQuality -> String
$cshow :: PrintQuality -> String
showsPrec :: Int -> PrintQuality -> ShowS
$cshowsPrec :: Int -> PrintQuality -> ShowS
Show, PrintQuality -> PrintQuality -> Bool
(PrintQuality -> PrintQuality -> Bool)
-> (PrintQuality -> PrintQuality -> Bool) -> Eq PrintQuality
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PrintQuality -> PrintQuality -> Bool
$c/= :: PrintQuality -> PrintQuality -> Bool
== :: PrintQuality -> PrintQuality -> Bool
$c== :: PrintQuality -> PrintQuality -> Bool
Eq)
instance P.Enum PrintQuality where
fromEnum :: PrintQuality -> Int
fromEnum PrintQuality
PrintQualityLow = Int
0
fromEnum PrintQuality
PrintQualityNormal = Int
1
fromEnum PrintQuality
PrintQualityHigh = Int
2
fromEnum PrintQuality
PrintQualityDraft = Int
3
fromEnum (AnotherPrintQuality Int
k) = Int
k
toEnum :: Int -> PrintQuality
toEnum Int
0 = PrintQuality
PrintQualityLow
toEnum Int
1 = PrintQuality
PrintQualityNormal
toEnum Int
2 = PrintQuality
PrintQualityHigh
toEnum Int
3 = PrintQuality
PrintQualityDraft
toEnum Int
k = Int -> PrintQuality
AnotherPrintQuality Int
k
instance P.Ord PrintQuality where
compare :: PrintQuality -> PrintQuality -> Ordering
compare PrintQuality
a PrintQuality
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PrintQuality -> Int
forall a. Enum a => a -> Int
P.fromEnum PrintQuality
a) (PrintQuality -> Int
forall a. Enum a => a -> Int
P.fromEnum PrintQuality
b)
type instance O.ParentTypes PrintQuality = '[]
instance O.HasParentTypes PrintQuality
foreign import ccall "gtk_print_quality_get_type" c_gtk_print_quality_get_type ::
IO GType
instance B.Types.TypedObject PrintQuality where
glibType :: IO GType
glibType = IO GType
c_gtk_print_quality_get_type
instance B.Types.BoxedEnum PrintQuality
data PrintPages =
PrintPagesAll
| PrintPagesCurrent
| PrintPagesRanges
| PrintPagesSelection
| AnotherPrintPages Int
deriving (Int -> PrintPages -> ShowS
[PrintPages] -> ShowS
PrintPages -> String
(Int -> PrintPages -> ShowS)
-> (PrintPages -> String)
-> ([PrintPages] -> ShowS)
-> Show PrintPages
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PrintPages] -> ShowS
$cshowList :: [PrintPages] -> ShowS
show :: PrintPages -> String
$cshow :: PrintPages -> String
showsPrec :: Int -> PrintPages -> ShowS
$cshowsPrec :: Int -> PrintPages -> ShowS
Show, PrintPages -> PrintPages -> Bool
(PrintPages -> PrintPages -> Bool)
-> (PrintPages -> PrintPages -> Bool) -> Eq PrintPages
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PrintPages -> PrintPages -> Bool
$c/= :: PrintPages -> PrintPages -> Bool
== :: PrintPages -> PrintPages -> Bool
$c== :: PrintPages -> PrintPages -> Bool
Eq)
instance P.Enum PrintPages where
fromEnum :: PrintPages -> Int
fromEnum PrintPages
PrintPagesAll = Int
0
fromEnum PrintPages
PrintPagesCurrent = Int
1
fromEnum PrintPages
PrintPagesRanges = Int
2
fromEnum PrintPages
PrintPagesSelection = Int
3
fromEnum (AnotherPrintPages Int
k) = Int
k
toEnum :: Int -> PrintPages
toEnum Int
0 = PrintPages
PrintPagesAll
toEnum Int
1 = PrintPages
PrintPagesCurrent
toEnum Int
2 = PrintPages
PrintPagesRanges
toEnum Int
3 = PrintPages
PrintPagesSelection
toEnum Int
k = Int -> PrintPages
AnotherPrintPages Int
k
instance P.Ord PrintPages where
compare :: PrintPages -> PrintPages -> Ordering
compare PrintPages
a PrintPages
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PrintPages -> Int
forall a. Enum a => a -> Int
P.fromEnum PrintPages
a) (PrintPages -> Int
forall a. Enum a => a -> Int
P.fromEnum PrintPages
b)
type instance O.ParentTypes PrintPages = '[]
instance O.HasParentTypes PrintPages
foreign import ccall "gtk_print_pages_get_type" c_gtk_print_pages_get_type ::
IO GType
instance B.Types.TypedObject PrintPages where
glibType :: IO GType
glibType = IO GType
c_gtk_print_pages_get_type
instance B.Types.BoxedEnum PrintPages
data PrintOperationResult =
PrintOperationResultError
| PrintOperationResultApply
| PrintOperationResultCancel
| PrintOperationResultInProgress
| AnotherPrintOperationResult Int
deriving (Int -> PrintOperationResult -> ShowS
[PrintOperationResult] -> ShowS
PrintOperationResult -> String
(Int -> PrintOperationResult -> ShowS)
-> (PrintOperationResult -> String)
-> ([PrintOperationResult] -> ShowS)
-> Show PrintOperationResult
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PrintOperationResult] -> ShowS
$cshowList :: [PrintOperationResult] -> ShowS
show :: PrintOperationResult -> String
$cshow :: PrintOperationResult -> String
showsPrec :: Int -> PrintOperationResult -> ShowS
$cshowsPrec :: Int -> PrintOperationResult -> ShowS
Show, PrintOperationResult -> PrintOperationResult -> Bool
(PrintOperationResult -> PrintOperationResult -> Bool)
-> (PrintOperationResult -> PrintOperationResult -> Bool)
-> Eq PrintOperationResult
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PrintOperationResult -> PrintOperationResult -> Bool
$c/= :: PrintOperationResult -> PrintOperationResult -> Bool
== :: PrintOperationResult -> PrintOperationResult -> Bool
$c== :: PrintOperationResult -> PrintOperationResult -> Bool
Eq)
instance P.Enum PrintOperationResult where
fromEnum :: PrintOperationResult -> Int
fromEnum PrintOperationResult
PrintOperationResultError = Int
0
fromEnum PrintOperationResult
PrintOperationResultApply = Int
1
fromEnum PrintOperationResult
PrintOperationResultCancel = Int
2
fromEnum PrintOperationResult
PrintOperationResultInProgress = Int
3
fromEnum (AnotherPrintOperationResult Int
k) = Int
k
toEnum :: Int -> PrintOperationResult
toEnum Int
0 = PrintOperationResult
PrintOperationResultError
toEnum Int
1 = PrintOperationResult
PrintOperationResultApply
toEnum Int
2 = PrintOperationResult
PrintOperationResultCancel
toEnum Int
3 = PrintOperationResult
PrintOperationResultInProgress
toEnum Int
k = Int -> PrintOperationResult
AnotherPrintOperationResult Int
k
instance P.Ord PrintOperationResult where
compare :: PrintOperationResult -> PrintOperationResult -> Ordering
compare PrintOperationResult
a PrintOperationResult
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PrintOperationResult -> Int
forall a. Enum a => a -> Int
P.fromEnum PrintOperationResult
a) (PrintOperationResult -> Int
forall a. Enum a => a -> Int
P.fromEnum PrintOperationResult
b)
type instance O.ParentTypes PrintOperationResult = '[]
instance O.HasParentTypes PrintOperationResult
foreign import ccall "gtk_print_operation_result_get_type" c_gtk_print_operation_result_get_type ::
IO GType
instance B.Types.TypedObject PrintOperationResult where
glibType :: IO GType
glibType = IO GType
c_gtk_print_operation_result_get_type
instance B.Types.BoxedEnum PrintOperationResult
data PrintOperationAction =
PrintOperationActionPrintDialog
| PrintOperationActionPrint
| PrintOperationActionPreview
| PrintOperationActionExport
| AnotherPrintOperationAction Int
deriving (Int -> PrintOperationAction -> ShowS
[PrintOperationAction] -> ShowS
PrintOperationAction -> String
(Int -> PrintOperationAction -> ShowS)
-> (PrintOperationAction -> String)
-> ([PrintOperationAction] -> ShowS)
-> Show PrintOperationAction
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PrintOperationAction] -> ShowS
$cshowList :: [PrintOperationAction] -> ShowS
show :: PrintOperationAction -> String
$cshow :: PrintOperationAction -> String
showsPrec :: Int -> PrintOperationAction -> ShowS
$cshowsPrec :: Int -> PrintOperationAction -> ShowS
Show, PrintOperationAction -> PrintOperationAction -> Bool
(PrintOperationAction -> PrintOperationAction -> Bool)
-> (PrintOperationAction -> PrintOperationAction -> Bool)
-> Eq PrintOperationAction
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PrintOperationAction -> PrintOperationAction -> Bool
$c/= :: PrintOperationAction -> PrintOperationAction -> Bool
== :: PrintOperationAction -> PrintOperationAction -> Bool
$c== :: PrintOperationAction -> PrintOperationAction -> Bool
Eq)
instance P.Enum PrintOperationAction where
fromEnum :: PrintOperationAction -> Int
fromEnum PrintOperationAction
PrintOperationActionPrintDialog = Int
0
fromEnum PrintOperationAction
PrintOperationActionPrint = Int
1
fromEnum PrintOperationAction
PrintOperationActionPreview = Int
2
fromEnum PrintOperationAction
PrintOperationActionExport = Int
3
fromEnum (AnotherPrintOperationAction Int
k) = Int
k
toEnum :: Int -> PrintOperationAction
toEnum Int
0 = PrintOperationAction
PrintOperationActionPrintDialog
toEnum Int
1 = PrintOperationAction
PrintOperationActionPrint
toEnum Int
2 = PrintOperationAction
PrintOperationActionPreview
toEnum Int
3 = PrintOperationAction
PrintOperationActionExport
toEnum Int
k = Int -> PrintOperationAction
AnotherPrintOperationAction Int
k
instance P.Ord PrintOperationAction where
compare :: PrintOperationAction -> PrintOperationAction -> Ordering
compare PrintOperationAction
a PrintOperationAction
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PrintOperationAction -> Int
forall a. Enum a => a -> Int
P.fromEnum PrintOperationAction
a) (PrintOperationAction -> Int
forall a. Enum a => a -> Int
P.fromEnum PrintOperationAction
b)
type instance O.ParentTypes PrintOperationAction = '[]
instance O.HasParentTypes PrintOperationAction
foreign import ccall "gtk_print_operation_action_get_type" c_gtk_print_operation_action_get_type ::
IO GType
instance B.Types.TypedObject PrintOperationAction where
glibType :: IO GType
glibType = IO GType
c_gtk_print_operation_action_get_type
instance B.Types.BoxedEnum PrintOperationAction
data PrintError =
PrintErrorGeneral
| PrintErrorInternalError
| PrintErrorNomem
| PrintErrorInvalidFile
| AnotherPrintError Int
deriving (Int -> PrintError -> ShowS
[PrintError] -> ShowS
PrintError -> String
(Int -> PrintError -> ShowS)
-> (PrintError -> String)
-> ([PrintError] -> ShowS)
-> Show PrintError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PrintError] -> ShowS
$cshowList :: [PrintError] -> ShowS
show :: PrintError -> String
$cshow :: PrintError -> String
showsPrec :: Int -> PrintError -> ShowS
$cshowsPrec :: Int -> PrintError -> ShowS
Show, PrintError -> PrintError -> Bool
(PrintError -> PrintError -> Bool)
-> (PrintError -> PrintError -> Bool) -> Eq PrintError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PrintError -> PrintError -> Bool
$c/= :: PrintError -> PrintError -> Bool
== :: PrintError -> PrintError -> Bool
$c== :: PrintError -> PrintError -> Bool
Eq)
instance P.Enum PrintError where
fromEnum :: PrintError -> Int
fromEnum PrintError
PrintErrorGeneral = Int
0
fromEnum PrintError
PrintErrorInternalError = Int
1
fromEnum PrintError
PrintErrorNomem = Int
2
fromEnum PrintError
PrintErrorInvalidFile = Int
3
fromEnum (AnotherPrintError Int
k) = Int
k
toEnum :: Int -> PrintError
toEnum Int
0 = PrintError
PrintErrorGeneral
toEnum Int
1 = PrintError
PrintErrorInternalError
toEnum Int
2 = PrintError
PrintErrorNomem
toEnum Int
3 = PrintError
PrintErrorInvalidFile
toEnum Int
k = Int -> PrintError
AnotherPrintError Int
k
instance P.Ord PrintError where
compare :: PrintError -> PrintError -> Ordering
compare PrintError
a PrintError
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PrintError -> Int
forall a. Enum a => a -> Int
P.fromEnum PrintError
a) (PrintError -> Int
forall a. Enum a => a -> Int
P.fromEnum PrintError
b)
instance GErrorClass PrintError where
gerrorClassDomain :: PrintError -> Text
gerrorClassDomain PrintError
_ = Text
"gtk-print-error-quark"
catchPrintError ::
IO a ->
(PrintError -> GErrorMessage -> IO a) ->
IO a
catchPrintError :: forall a. IO a -> (PrintError -> Text -> IO a) -> IO a
catchPrintError = IO a -> (PrintError -> Text -> IO a) -> IO a
forall err a.
GErrorClass err =>
IO a -> (err -> Text -> IO a) -> IO a
catchGErrorJustDomain
handlePrintError ::
(PrintError -> GErrorMessage -> IO a) ->
IO a ->
IO a
handlePrintError :: forall a. (PrintError -> Text -> IO a) -> IO a -> IO a
handlePrintError = (PrintError -> Text -> IO a) -> IO a -> IO a
forall err a.
GErrorClass err =>
(err -> Text -> IO a) -> IO a -> IO a
handleGErrorJustDomain
type instance O.ParentTypes PrintError = '[]
instance O.HasParentTypes PrintError
foreign import ccall "gtk_print_error_get_type" c_gtk_print_error_get_type ::
IO GType
instance B.Types.TypedObject PrintError where
glibType :: IO GType
glibType = IO GType
c_gtk_print_error_get_type
instance B.Types.BoxedEnum PrintError
data PrintDuplex =
PrintDuplexSimplex
| PrintDuplexHorizontal
| PrintDuplexVertical
| AnotherPrintDuplex Int
deriving (Int -> PrintDuplex -> ShowS
[PrintDuplex] -> ShowS
PrintDuplex -> String
(Int -> PrintDuplex -> ShowS)
-> (PrintDuplex -> String)
-> ([PrintDuplex] -> ShowS)
-> Show PrintDuplex
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PrintDuplex] -> ShowS
$cshowList :: [PrintDuplex] -> ShowS
show :: PrintDuplex -> String
$cshow :: PrintDuplex -> String
showsPrec :: Int -> PrintDuplex -> ShowS
$cshowsPrec :: Int -> PrintDuplex -> ShowS
Show, PrintDuplex -> PrintDuplex -> Bool
(PrintDuplex -> PrintDuplex -> Bool)
-> (PrintDuplex -> PrintDuplex -> Bool) -> Eq PrintDuplex
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PrintDuplex -> PrintDuplex -> Bool
$c/= :: PrintDuplex -> PrintDuplex -> Bool
== :: PrintDuplex -> PrintDuplex -> Bool
$c== :: PrintDuplex -> PrintDuplex -> Bool
Eq)
instance P.Enum PrintDuplex where
fromEnum :: PrintDuplex -> Int
fromEnum PrintDuplex
PrintDuplexSimplex = Int
0
fromEnum PrintDuplex
PrintDuplexHorizontal = Int
1
fromEnum PrintDuplex
PrintDuplexVertical = Int
2
fromEnum (AnotherPrintDuplex Int
k) = Int
k
toEnum :: Int -> PrintDuplex
toEnum Int
0 = PrintDuplex
PrintDuplexSimplex
toEnum Int
1 = PrintDuplex
PrintDuplexHorizontal
toEnum Int
2 = PrintDuplex
PrintDuplexVertical
toEnum Int
k = Int -> PrintDuplex
AnotherPrintDuplex Int
k
instance P.Ord PrintDuplex where
compare :: PrintDuplex -> PrintDuplex -> Ordering
compare PrintDuplex
a PrintDuplex
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PrintDuplex -> Int
forall a. Enum a => a -> Int
P.fromEnum PrintDuplex
a) (PrintDuplex -> Int
forall a. Enum a => a -> Int
P.fromEnum PrintDuplex
b)
type instance O.ParentTypes PrintDuplex = '[]
instance O.HasParentTypes PrintDuplex
foreign import ccall "gtk_print_duplex_get_type" c_gtk_print_duplex_get_type ::
IO GType
instance B.Types.TypedObject PrintDuplex where
glibType :: IO GType
glibType = IO GType
c_gtk_print_duplex_get_type
instance B.Types.BoxedEnum PrintDuplex
data PositionType =
PositionTypeLeft
| PositionTypeRight
| PositionTypeTop
| PositionTypeBottom
| AnotherPositionType Int
deriving (Int -> PositionType -> ShowS
[PositionType] -> ShowS
PositionType -> String
(Int -> PositionType -> ShowS)
-> (PositionType -> String)
-> ([PositionType] -> ShowS)
-> Show PositionType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PositionType] -> ShowS
$cshowList :: [PositionType] -> ShowS
show :: PositionType -> String
$cshow :: PositionType -> String
showsPrec :: Int -> PositionType -> ShowS
$cshowsPrec :: Int -> PositionType -> ShowS
Show, PositionType -> PositionType -> Bool
(PositionType -> PositionType -> Bool)
-> (PositionType -> PositionType -> Bool) -> Eq PositionType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PositionType -> PositionType -> Bool
$c/= :: PositionType -> PositionType -> Bool
== :: PositionType -> PositionType -> Bool
$c== :: PositionType -> PositionType -> Bool
Eq)
instance P.Enum PositionType where
fromEnum :: PositionType -> Int
fromEnum PositionType
PositionTypeLeft = Int
0
fromEnum PositionType
PositionTypeRight = Int
1
fromEnum PositionType
PositionTypeTop = Int
2
fromEnum PositionType
PositionTypeBottom = Int
3
fromEnum (AnotherPositionType Int
k) = Int
k
toEnum :: Int -> PositionType
toEnum Int
0 = PositionType
PositionTypeLeft
toEnum Int
1 = PositionType
PositionTypeRight
toEnum Int
2 = PositionType
PositionTypeTop
toEnum Int
3 = PositionType
PositionTypeBottom
toEnum Int
k = Int -> PositionType
AnotherPositionType Int
k
instance P.Ord PositionType where
compare :: PositionType -> PositionType -> Ordering
compare PositionType
a PositionType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PositionType -> Int
forall a. Enum a => a -> Int
P.fromEnum PositionType
a) (PositionType -> Int
forall a. Enum a => a -> Int
P.fromEnum PositionType
b)
type instance O.ParentTypes PositionType = '[]
instance O.HasParentTypes PositionType
foreign import ccall "gtk_position_type_get_type" c_gtk_position_type_get_type ::
IO GType
instance B.Types.TypedObject PositionType where
glibType :: IO GType
glibType = IO GType
c_gtk_position_type_get_type
instance B.Types.BoxedEnum PositionType
data PopoverConstraint =
PopoverConstraintNone
| PopoverConstraintWindow
| AnotherPopoverConstraint Int
deriving (Int -> PopoverConstraint -> ShowS
[PopoverConstraint] -> ShowS
PopoverConstraint -> String
(Int -> PopoverConstraint -> ShowS)
-> (PopoverConstraint -> String)
-> ([PopoverConstraint] -> ShowS)
-> Show PopoverConstraint
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PopoverConstraint] -> ShowS
$cshowList :: [PopoverConstraint] -> ShowS
show :: PopoverConstraint -> String
$cshow :: PopoverConstraint -> String
showsPrec :: Int -> PopoverConstraint -> ShowS
$cshowsPrec :: Int -> PopoverConstraint -> ShowS
Show, PopoverConstraint -> PopoverConstraint -> Bool
(PopoverConstraint -> PopoverConstraint -> Bool)
-> (PopoverConstraint -> PopoverConstraint -> Bool)
-> Eq PopoverConstraint
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PopoverConstraint -> PopoverConstraint -> Bool
$c/= :: PopoverConstraint -> PopoverConstraint -> Bool
== :: PopoverConstraint -> PopoverConstraint -> Bool
$c== :: PopoverConstraint -> PopoverConstraint -> Bool
Eq)
instance P.Enum PopoverConstraint where
fromEnum :: PopoverConstraint -> Int
fromEnum PopoverConstraint
PopoverConstraintNone = Int
0
fromEnum PopoverConstraint
PopoverConstraintWindow = Int
1
fromEnum (AnotherPopoverConstraint Int
k) = Int
k
toEnum :: Int -> PopoverConstraint
toEnum Int
0 = PopoverConstraint
PopoverConstraintNone
toEnum Int
1 = PopoverConstraint
PopoverConstraintWindow
toEnum Int
k = Int -> PopoverConstraint
AnotherPopoverConstraint Int
k
instance P.Ord PopoverConstraint where
compare :: PopoverConstraint -> PopoverConstraint -> Ordering
compare PopoverConstraint
a PopoverConstraint
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PopoverConstraint -> Int
forall a. Enum a => a -> Int
P.fromEnum PopoverConstraint
a) (PopoverConstraint -> Int
forall a. Enum a => a -> Int
P.fromEnum PopoverConstraint
b)
type instance O.ParentTypes PopoverConstraint = '[]
instance O.HasParentTypes PopoverConstraint
foreign import ccall "gtk_popover_constraint_get_type" c_gtk_popover_constraint_get_type ::
IO GType
instance B.Types.TypedObject PopoverConstraint where
glibType :: IO GType
glibType = IO GType
c_gtk_popover_constraint_get_type
instance B.Types.BoxedEnum PopoverConstraint
data PolicyType =
PolicyTypeAlways
| PolicyTypeAutomatic
| PolicyTypeNever
| PolicyTypeExternal
| AnotherPolicyType Int
deriving (Int -> PolicyType -> ShowS
[PolicyType] -> ShowS
PolicyType -> String
(Int -> PolicyType -> ShowS)
-> (PolicyType -> String)
-> ([PolicyType] -> ShowS)
-> Show PolicyType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PolicyType] -> ShowS
$cshowList :: [PolicyType] -> ShowS
show :: PolicyType -> String
$cshow :: PolicyType -> String
showsPrec :: Int -> PolicyType -> ShowS
$cshowsPrec :: Int -> PolicyType -> ShowS
Show, PolicyType -> PolicyType -> Bool
(PolicyType -> PolicyType -> Bool)
-> (PolicyType -> PolicyType -> Bool) -> Eq PolicyType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PolicyType -> PolicyType -> Bool
$c/= :: PolicyType -> PolicyType -> Bool
== :: PolicyType -> PolicyType -> Bool
$c== :: PolicyType -> PolicyType -> Bool
Eq)
instance P.Enum PolicyType where
fromEnum :: PolicyType -> Int
fromEnum PolicyType
PolicyTypeAlways = Int
0
fromEnum PolicyType
PolicyTypeAutomatic = Int
1
fromEnum PolicyType
PolicyTypeNever = Int
2
fromEnum PolicyType
PolicyTypeExternal = Int
3
fromEnum (AnotherPolicyType Int
k) = Int
k
toEnum :: Int -> PolicyType
toEnum Int
0 = PolicyType
PolicyTypeAlways
toEnum Int
1 = PolicyType
PolicyTypeAutomatic
toEnum Int
2 = PolicyType
PolicyTypeNever
toEnum Int
3 = PolicyType
PolicyTypeExternal
toEnum Int
k = Int -> PolicyType
AnotherPolicyType Int
k
instance P.Ord PolicyType where
compare :: PolicyType -> PolicyType -> Ordering
compare PolicyType
a PolicyType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PolicyType -> Int
forall a. Enum a => a -> Int
P.fromEnum PolicyType
a) (PolicyType -> Int
forall a. Enum a => a -> Int
P.fromEnum PolicyType
b)
type instance O.ParentTypes PolicyType = '[]
instance O.HasParentTypes PolicyType
foreign import ccall "gtk_policy_type_get_type" c_gtk_policy_type_get_type ::
IO GType
instance B.Types.TypedObject PolicyType where
glibType :: IO GType
glibType = IO GType
c_gtk_policy_type_get_type
instance B.Types.BoxedEnum PolicyType
{-# DEPRECATED PathType ["(Since version 3.0)"] #-}
data PathType =
PathTypeWidget
| PathTypeWidgetClass
| PathTypeClass
| AnotherPathType Int
deriving (Int -> PathType -> ShowS
[PathType] -> ShowS
PathType -> String
(Int -> PathType -> ShowS)
-> (PathType -> String) -> ([PathType] -> ShowS) -> Show PathType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PathType] -> ShowS
$cshowList :: [PathType] -> ShowS
show :: PathType -> String
$cshow :: PathType -> String
showsPrec :: Int -> PathType -> ShowS
$cshowsPrec :: Int -> PathType -> ShowS
Show, PathType -> PathType -> Bool
(PathType -> PathType -> Bool)
-> (PathType -> PathType -> Bool) -> Eq PathType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PathType -> PathType -> Bool
$c/= :: PathType -> PathType -> Bool
== :: PathType -> PathType -> Bool
$c== :: PathType -> PathType -> Bool
Eq)
instance P.Enum PathType where
fromEnum :: PathType -> Int
fromEnum PathType
PathTypeWidget = Int
0
fromEnum PathType
PathTypeWidgetClass = Int
1
fromEnum PathType
PathTypeClass = Int
2
fromEnum (AnotherPathType Int
k) = Int
k
toEnum :: Int -> PathType
toEnum Int
0 = PathType
PathTypeWidget
toEnum Int
1 = PathType
PathTypeWidgetClass
toEnum Int
2 = PathType
PathTypeClass
toEnum Int
k = Int -> PathType
AnotherPathType Int
k
instance P.Ord PathType where
compare :: PathType -> PathType -> Ordering
compare PathType
a PathType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PathType -> Int
forall a. Enum a => a -> Int
P.fromEnum PathType
a) (PathType -> Int
forall a. Enum a => a -> Int
P.fromEnum PathType
b)
type instance O.ParentTypes PathType = '[]
instance O.HasParentTypes PathType
foreign import ccall "gtk_path_type_get_type" c_gtk_path_type_get_type ::
IO GType
instance B.Types.TypedObject PathType where
glibType :: IO GType
glibType = IO GType
c_gtk_path_type_get_type
instance B.Types.BoxedEnum PathType
{-# DEPRECATED PathPriorityType ["(Since version 3.0)"] #-}
data PathPriorityType =
PathPriorityTypeLowest
| PathPriorityTypeGtk
| PathPriorityTypeApplication
| PathPriorityTypeTheme
| PathPriorityTypeRc
| PathPriorityTypeHighest
| AnotherPathPriorityType Int
deriving (Int -> PathPriorityType -> ShowS
[PathPriorityType] -> ShowS
PathPriorityType -> String
(Int -> PathPriorityType -> ShowS)
-> (PathPriorityType -> String)
-> ([PathPriorityType] -> ShowS)
-> Show PathPriorityType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PathPriorityType] -> ShowS
$cshowList :: [PathPriorityType] -> ShowS
show :: PathPriorityType -> String
$cshow :: PathPriorityType -> String
showsPrec :: Int -> PathPriorityType -> ShowS
$cshowsPrec :: Int -> PathPriorityType -> ShowS
Show, PathPriorityType -> PathPriorityType -> Bool
(PathPriorityType -> PathPriorityType -> Bool)
-> (PathPriorityType -> PathPriorityType -> Bool)
-> Eq PathPriorityType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PathPriorityType -> PathPriorityType -> Bool
$c/= :: PathPriorityType -> PathPriorityType -> Bool
== :: PathPriorityType -> PathPriorityType -> Bool
$c== :: PathPriorityType -> PathPriorityType -> Bool
Eq)
instance P.Enum PathPriorityType where
fromEnum :: PathPriorityType -> Int
fromEnum PathPriorityType
PathPriorityTypeLowest = Int
0
fromEnum PathPriorityType
PathPriorityTypeGtk = Int
4
fromEnum PathPriorityType
PathPriorityTypeApplication = Int
8
fromEnum PathPriorityType
PathPriorityTypeTheme = Int
10
fromEnum PathPriorityType
PathPriorityTypeRc = Int
12
fromEnum PathPriorityType
PathPriorityTypeHighest = Int
15
fromEnum (AnotherPathPriorityType Int
k) = Int
k
toEnum :: Int -> PathPriorityType
toEnum Int
0 = PathPriorityType
PathPriorityTypeLowest
toEnum Int
4 = PathPriorityType
PathPriorityTypeGtk
toEnum Int
8 = PathPriorityType
PathPriorityTypeApplication
toEnum Int
10 = PathPriorityType
PathPriorityTypeTheme
toEnum Int
12 = PathPriorityType
PathPriorityTypeRc
toEnum Int
15 = PathPriorityType
PathPriorityTypeHighest
toEnum Int
k = Int -> PathPriorityType
AnotherPathPriorityType Int
k
instance P.Ord PathPriorityType where
compare :: PathPriorityType -> PathPriorityType -> Ordering
compare PathPriorityType
a PathPriorityType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PathPriorityType -> Int
forall a. Enum a => a -> Int
P.fromEnum PathPriorityType
a) (PathPriorityType -> Int
forall a. Enum a => a -> Int
P.fromEnum PathPriorityType
b)
type instance O.ParentTypes PathPriorityType = '[]
instance O.HasParentTypes PathPriorityType
foreign import ccall "gtk_path_priority_type_get_type" c_gtk_path_priority_type_get_type ::
IO GType
instance B.Types.TypedObject PathPriorityType where
glibType :: IO GType
glibType = IO GType
c_gtk_path_priority_type_get_type
instance B.Types.BoxedEnum PathPriorityType
data PanDirection =
PanDirectionLeft
| PanDirectionRight
| PanDirectionUp
| PanDirectionDown
| AnotherPanDirection Int
deriving (Int -> PanDirection -> ShowS
[PanDirection] -> ShowS
PanDirection -> String
(Int -> PanDirection -> ShowS)
-> (PanDirection -> String)
-> ([PanDirection] -> ShowS)
-> Show PanDirection
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PanDirection] -> ShowS
$cshowList :: [PanDirection] -> ShowS
show :: PanDirection -> String
$cshow :: PanDirection -> String
showsPrec :: Int -> PanDirection -> ShowS
$cshowsPrec :: Int -> PanDirection -> ShowS
Show, PanDirection -> PanDirection -> Bool
(PanDirection -> PanDirection -> Bool)
-> (PanDirection -> PanDirection -> Bool) -> Eq PanDirection
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PanDirection -> PanDirection -> Bool
$c/= :: PanDirection -> PanDirection -> Bool
== :: PanDirection -> PanDirection -> Bool
$c== :: PanDirection -> PanDirection -> Bool
Eq)
instance P.Enum PanDirection where
fromEnum :: PanDirection -> Int
fromEnum PanDirection
PanDirectionLeft = Int
0
fromEnum PanDirection
PanDirectionRight = Int
1
fromEnum PanDirection
PanDirectionUp = Int
2
fromEnum PanDirection
PanDirectionDown = Int
3
fromEnum (AnotherPanDirection Int
k) = Int
k
toEnum :: Int -> PanDirection
toEnum Int
0 = PanDirection
PanDirectionLeft
toEnum Int
1 = PanDirection
PanDirectionRight
toEnum Int
2 = PanDirection
PanDirectionUp
toEnum Int
3 = PanDirection
PanDirectionDown
toEnum Int
k = Int -> PanDirection
AnotherPanDirection Int
k
instance P.Ord PanDirection where
compare :: PanDirection -> PanDirection -> Ordering
compare PanDirection
a PanDirection
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PanDirection -> Int
forall a. Enum a => a -> Int
P.fromEnum PanDirection
a) (PanDirection -> Int
forall a. Enum a => a -> Int
P.fromEnum PanDirection
b)
type instance O.ParentTypes PanDirection = '[]
instance O.HasParentTypes PanDirection
foreign import ccall "gtk_pan_direction_get_type" c_gtk_pan_direction_get_type ::
IO GType
instance B.Types.TypedObject PanDirection where
glibType :: IO GType
glibType = IO GType
c_gtk_pan_direction_get_type
instance B.Types.BoxedEnum PanDirection
data PageSet =
PageSetAll
| PageSetEven
| PageSetOdd
| AnotherPageSet Int
deriving (Int -> PageSet -> ShowS
[PageSet] -> ShowS
PageSet -> String
(Int -> PageSet -> ShowS)
-> (PageSet -> String) -> ([PageSet] -> ShowS) -> Show PageSet
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PageSet] -> ShowS
$cshowList :: [PageSet] -> ShowS
show :: PageSet -> String
$cshow :: PageSet -> String
showsPrec :: Int -> PageSet -> ShowS
$cshowsPrec :: Int -> PageSet -> ShowS
Show, PageSet -> PageSet -> Bool
(PageSet -> PageSet -> Bool)
-> (PageSet -> PageSet -> Bool) -> Eq PageSet
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PageSet -> PageSet -> Bool
$c/= :: PageSet -> PageSet -> Bool
== :: PageSet -> PageSet -> Bool
$c== :: PageSet -> PageSet -> Bool
Eq)
instance P.Enum PageSet where
fromEnum :: PageSet -> Int
fromEnum PageSet
PageSetAll = Int
0
fromEnum PageSet
PageSetEven = Int
1
fromEnum PageSet
PageSetOdd = Int
2
fromEnum (AnotherPageSet Int
k) = Int
k
toEnum :: Int -> PageSet
toEnum Int
0 = PageSet
PageSetAll
toEnum Int
1 = PageSet
PageSetEven
toEnum Int
2 = PageSet
PageSetOdd
toEnum Int
k = Int -> PageSet
AnotherPageSet Int
k
instance P.Ord PageSet where
compare :: PageSet -> PageSet -> Ordering
compare PageSet
a PageSet
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PageSet -> Int
forall a. Enum a => a -> Int
P.fromEnum PageSet
a) (PageSet -> Int
forall a. Enum a => a -> Int
P.fromEnum PageSet
b)
type instance O.ParentTypes PageSet = '[]
instance O.HasParentTypes PageSet
foreign import ccall "gtk_page_set_get_type" c_gtk_page_set_get_type ::
IO GType
instance B.Types.TypedObject PageSet where
glibType :: IO GType
glibType = IO GType
c_gtk_page_set_get_type
instance B.Types.BoxedEnum PageSet
data PageOrientation =
PageOrientationPortrait
| PageOrientationLandscape
| PageOrientationReversePortrait
| PageOrientationReverseLandscape
| AnotherPageOrientation Int
deriving (Int -> PageOrientation -> ShowS
[PageOrientation] -> ShowS
PageOrientation -> String
(Int -> PageOrientation -> ShowS)
-> (PageOrientation -> String)
-> ([PageOrientation] -> ShowS)
-> Show PageOrientation
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PageOrientation] -> ShowS
$cshowList :: [PageOrientation] -> ShowS
show :: PageOrientation -> String
$cshow :: PageOrientation -> String
showsPrec :: Int -> PageOrientation -> ShowS
$cshowsPrec :: Int -> PageOrientation -> ShowS
Show, PageOrientation -> PageOrientation -> Bool
(PageOrientation -> PageOrientation -> Bool)
-> (PageOrientation -> PageOrientation -> Bool)
-> Eq PageOrientation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PageOrientation -> PageOrientation -> Bool
$c/= :: PageOrientation -> PageOrientation -> Bool
== :: PageOrientation -> PageOrientation -> Bool
$c== :: PageOrientation -> PageOrientation -> Bool
Eq)
instance P.Enum PageOrientation where
fromEnum :: PageOrientation -> Int
fromEnum PageOrientation
PageOrientationPortrait = Int
0
fromEnum PageOrientation
PageOrientationLandscape = Int
1
fromEnum PageOrientation
PageOrientationReversePortrait = Int
2
fromEnum PageOrientation
PageOrientationReverseLandscape = Int
3
fromEnum (AnotherPageOrientation Int
k) = Int
k
toEnum :: Int -> PageOrientation
toEnum Int
0 = PageOrientation
PageOrientationPortrait
toEnum Int
1 = PageOrientation
PageOrientationLandscape
toEnum Int
2 = PageOrientation
PageOrientationReversePortrait
toEnum Int
3 = PageOrientation
PageOrientationReverseLandscape
toEnum Int
k = Int -> PageOrientation
AnotherPageOrientation Int
k
instance P.Ord PageOrientation where
compare :: PageOrientation -> PageOrientation -> Ordering
compare PageOrientation
a PageOrientation
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PageOrientation -> Int
forall a. Enum a => a -> Int
P.fromEnum PageOrientation
a) (PageOrientation -> Int
forall a. Enum a => a -> Int
P.fromEnum PageOrientation
b)
type instance O.ParentTypes PageOrientation = '[]
instance O.HasParentTypes PageOrientation
foreign import ccall "gtk_page_orientation_get_type" c_gtk_page_orientation_get_type ::
IO GType
instance B.Types.TypedObject PageOrientation where
glibType :: IO GType
glibType = IO GType
c_gtk_page_orientation_get_type
instance B.Types.BoxedEnum PageOrientation
data PadActionType =
PadActionTypeButton
| PadActionTypeRing
| PadActionTypeStrip
| AnotherPadActionType Int
deriving (Int -> PadActionType -> ShowS
[PadActionType] -> ShowS
PadActionType -> String
(Int -> PadActionType -> ShowS)
-> (PadActionType -> String)
-> ([PadActionType] -> ShowS)
-> Show PadActionType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PadActionType] -> ShowS
$cshowList :: [PadActionType] -> ShowS
show :: PadActionType -> String
$cshow :: PadActionType -> String
showsPrec :: Int -> PadActionType -> ShowS
$cshowsPrec :: Int -> PadActionType -> ShowS
Show, PadActionType -> PadActionType -> Bool
(PadActionType -> PadActionType -> Bool)
-> (PadActionType -> PadActionType -> Bool) -> Eq PadActionType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PadActionType -> PadActionType -> Bool
$c/= :: PadActionType -> PadActionType -> Bool
== :: PadActionType -> PadActionType -> Bool
$c== :: PadActionType -> PadActionType -> Bool
Eq)
instance P.Enum PadActionType where
fromEnum :: PadActionType -> Int
fromEnum PadActionType
PadActionTypeButton = Int
0
fromEnum PadActionType
PadActionTypeRing = Int
1
fromEnum PadActionType
PadActionTypeStrip = Int
2
fromEnum (AnotherPadActionType Int
k) = Int
k
toEnum :: Int -> PadActionType
toEnum Int
0 = PadActionType
PadActionTypeButton
toEnum Int
1 = PadActionType
PadActionTypeRing
toEnum Int
2 = PadActionType
PadActionTypeStrip
toEnum Int
k = Int -> PadActionType
AnotherPadActionType Int
k
instance P.Ord PadActionType where
compare :: PadActionType -> PadActionType -> Ordering
compare PadActionType
a PadActionType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PadActionType -> Int
forall a. Enum a => a -> Int
P.fromEnum PadActionType
a) (PadActionType -> Int
forall a. Enum a => a -> Int
P.fromEnum PadActionType
b)
type instance O.ParentTypes PadActionType = '[]
instance O.HasParentTypes PadActionType
foreign import ccall "gtk_pad_action_type_get_type" c_gtk_pad_action_type_get_type ::
IO GType
instance B.Types.TypedObject PadActionType where
glibType :: IO GType
glibType = IO GType
c_gtk_pad_action_type_get_type
instance B.Types.BoxedEnum PadActionType
data PackType =
PackTypeStart
| PackTypeEnd
| AnotherPackType Int
deriving (Int -> PackType -> ShowS
[PackType] -> ShowS
PackType -> String
(Int -> PackType -> ShowS)
-> (PackType -> String) -> ([PackType] -> ShowS) -> Show PackType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PackType] -> ShowS
$cshowList :: [PackType] -> ShowS
show :: PackType -> String
$cshow :: PackType -> String
showsPrec :: Int -> PackType -> ShowS
$cshowsPrec :: Int -> PackType -> ShowS
Show, PackType -> PackType -> Bool
(PackType -> PackType -> Bool)
-> (PackType -> PackType -> Bool) -> Eq PackType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PackType -> PackType -> Bool
$c/= :: PackType -> PackType -> Bool
== :: PackType -> PackType -> Bool
$c== :: PackType -> PackType -> Bool
Eq)
instance P.Enum PackType where
fromEnum :: PackType -> Int
fromEnum PackType
PackTypeStart = Int
0
fromEnum PackType
PackTypeEnd = Int
1
fromEnum (AnotherPackType Int
k) = Int
k
toEnum :: Int -> PackType
toEnum Int
0 = PackType
PackTypeStart
toEnum Int
1 = PackType
PackTypeEnd
toEnum Int
k = Int -> PackType
AnotherPackType Int
k
instance P.Ord PackType where
compare :: PackType -> PackType -> Ordering
compare PackType
a PackType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PackType -> Int
forall a. Enum a => a -> Int
P.fromEnum PackType
a) (PackType -> Int
forall a. Enum a => a -> Int
P.fromEnum PackType
b)
type instance O.ParentTypes PackType = '[]
instance O.HasParentTypes PackType
foreign import ccall "gtk_pack_type_get_type" c_gtk_pack_type_get_type ::
IO GType
instance B.Types.TypedObject PackType where
glibType :: IO GType
glibType = IO GType
c_gtk_pack_type_get_type
instance B.Types.BoxedEnum PackType
data PackDirection =
PackDirectionLtr
| PackDirectionRtl
| PackDirectionTtb
| PackDirectionBtt
| AnotherPackDirection Int
deriving (Int -> PackDirection -> ShowS
[PackDirection] -> ShowS
PackDirection -> String
(Int -> PackDirection -> ShowS)
-> (PackDirection -> String)
-> ([PackDirection] -> ShowS)
-> Show PackDirection
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PackDirection] -> ShowS
$cshowList :: [PackDirection] -> ShowS
show :: PackDirection -> String
$cshow :: PackDirection -> String
showsPrec :: Int -> PackDirection -> ShowS
$cshowsPrec :: Int -> PackDirection -> ShowS
Show, PackDirection -> PackDirection -> Bool
(PackDirection -> PackDirection -> Bool)
-> (PackDirection -> PackDirection -> Bool) -> Eq PackDirection
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PackDirection -> PackDirection -> Bool
$c/= :: PackDirection -> PackDirection -> Bool
== :: PackDirection -> PackDirection -> Bool
$c== :: PackDirection -> PackDirection -> Bool
Eq)
instance P.Enum PackDirection where
fromEnum :: PackDirection -> Int
fromEnum PackDirection
PackDirectionLtr = Int
0
fromEnum PackDirection
PackDirectionRtl = Int
1
fromEnum PackDirection
PackDirectionTtb = Int
2
fromEnum PackDirection
PackDirectionBtt = Int
3
fromEnum (AnotherPackDirection Int
k) = Int
k
toEnum :: Int -> PackDirection
toEnum Int
0 = PackDirection
PackDirectionLtr
toEnum Int
1 = PackDirection
PackDirectionRtl
toEnum Int
2 = PackDirection
PackDirectionTtb
toEnum Int
3 = PackDirection
PackDirectionBtt
toEnum Int
k = Int -> PackDirection
AnotherPackDirection Int
k
instance P.Ord PackDirection where
compare :: PackDirection -> PackDirection -> Ordering
compare PackDirection
a PackDirection
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PackDirection -> Int
forall a. Enum a => a -> Int
P.fromEnum PackDirection
a) (PackDirection -> Int
forall a. Enum a => a -> Int
P.fromEnum PackDirection
b)
type instance O.ParentTypes PackDirection = '[]
instance O.HasParentTypes PackDirection
foreign import ccall "gtk_pack_direction_get_type" c_gtk_pack_direction_get_type ::
IO GType
instance B.Types.TypedObject PackDirection where
glibType :: IO GType
glibType = IO GType
c_gtk_pack_direction_get_type
instance B.Types.BoxedEnum PackDirection
data Orientation =
OrientationHorizontal
| OrientationVertical
| AnotherOrientation Int
deriving (Int -> Orientation -> ShowS
[Orientation] -> ShowS
Orientation -> String
(Int -> Orientation -> ShowS)
-> (Orientation -> String)
-> ([Orientation] -> ShowS)
-> Show Orientation
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Orientation] -> ShowS
$cshowList :: [Orientation] -> ShowS
show :: Orientation -> String
$cshow :: Orientation -> String
showsPrec :: Int -> Orientation -> ShowS
$cshowsPrec :: Int -> Orientation -> ShowS
Show, Orientation -> Orientation -> Bool
(Orientation -> Orientation -> Bool)
-> (Orientation -> Orientation -> Bool) -> Eq Orientation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Orientation -> Orientation -> Bool
$c/= :: Orientation -> Orientation -> Bool
== :: Orientation -> Orientation -> Bool
$c== :: Orientation -> Orientation -> Bool
Eq)
instance P.Enum Orientation where
fromEnum :: Orientation -> Int
fromEnum Orientation
OrientationHorizontal = Int
0
fromEnum Orientation
OrientationVertical = Int
1
fromEnum (AnotherOrientation Int
k) = Int
k
toEnum :: Int -> Orientation
toEnum Int
0 = Orientation
OrientationHorizontal
toEnum Int
1 = Orientation
OrientationVertical
toEnum Int
k = Int -> Orientation
AnotherOrientation Int
k
instance P.Ord Orientation where
compare :: Orientation -> Orientation -> Ordering
compare Orientation
a Orientation
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (Orientation -> Int
forall a. Enum a => a -> Int
P.fromEnum Orientation
a) (Orientation -> Int
forall a. Enum a => a -> Int
P.fromEnum Orientation
b)
type instance O.ParentTypes Orientation = '[]
instance O.HasParentTypes Orientation
foreign import ccall "gtk_orientation_get_type" c_gtk_orientation_get_type ::
IO GType
instance B.Types.TypedObject Orientation where
glibType :: IO GType
glibType = IO GType
c_gtk_orientation_get_type
instance B.Types.BoxedEnum Orientation
data NumberUpLayout =
NumberUpLayoutLrtb
| NumberUpLayoutLrbt
| NumberUpLayoutRltb
| NumberUpLayoutRlbt
| NumberUpLayoutTblr
| NumberUpLayoutTbrl
| NumberUpLayoutBtlr
| NumberUpLayoutBtrl
| AnotherNumberUpLayout Int
deriving (Int -> NumberUpLayout -> ShowS
[NumberUpLayout] -> ShowS
NumberUpLayout -> String
(Int -> NumberUpLayout -> ShowS)
-> (NumberUpLayout -> String)
-> ([NumberUpLayout] -> ShowS)
-> Show NumberUpLayout
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NumberUpLayout] -> ShowS
$cshowList :: [NumberUpLayout] -> ShowS
show :: NumberUpLayout -> String
$cshow :: NumberUpLayout -> String
showsPrec :: Int -> NumberUpLayout -> ShowS
$cshowsPrec :: Int -> NumberUpLayout -> ShowS
Show, NumberUpLayout -> NumberUpLayout -> Bool
(NumberUpLayout -> NumberUpLayout -> Bool)
-> (NumberUpLayout -> NumberUpLayout -> Bool) -> Eq NumberUpLayout
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NumberUpLayout -> NumberUpLayout -> Bool
$c/= :: NumberUpLayout -> NumberUpLayout -> Bool
== :: NumberUpLayout -> NumberUpLayout -> Bool
$c== :: NumberUpLayout -> NumberUpLayout -> Bool
Eq)
instance P.Enum NumberUpLayout where
fromEnum :: NumberUpLayout -> Int
fromEnum NumberUpLayout
NumberUpLayoutLrtb = Int
0
fromEnum NumberUpLayout
NumberUpLayoutLrbt = Int
1
fromEnum NumberUpLayout
NumberUpLayoutRltb = Int
2
fromEnum NumberUpLayout
NumberUpLayoutRlbt = Int
3
fromEnum NumberUpLayout
NumberUpLayoutTblr = Int
4
fromEnum NumberUpLayout
NumberUpLayoutTbrl = Int
5
fromEnum NumberUpLayout
NumberUpLayoutBtlr = Int
6
fromEnum NumberUpLayout
NumberUpLayoutBtrl = Int
7
fromEnum (AnotherNumberUpLayout Int
k) = Int
k
toEnum :: Int -> NumberUpLayout
toEnum Int
0 = NumberUpLayout
NumberUpLayoutLrtb
toEnum Int
1 = NumberUpLayout
NumberUpLayoutLrbt
toEnum Int
2 = NumberUpLayout
NumberUpLayoutRltb
toEnum Int
3 = NumberUpLayout
NumberUpLayoutRlbt
toEnum Int
4 = NumberUpLayout
NumberUpLayoutTblr
toEnum Int
5 = NumberUpLayout
NumberUpLayoutTbrl
toEnum Int
6 = NumberUpLayout
NumberUpLayoutBtlr
toEnum Int
7 = NumberUpLayout
NumberUpLayoutBtrl
toEnum Int
k = Int -> NumberUpLayout
AnotherNumberUpLayout Int
k
instance P.Ord NumberUpLayout where
compare :: NumberUpLayout -> NumberUpLayout -> Ordering
compare NumberUpLayout
a NumberUpLayout
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (NumberUpLayout -> Int
forall a. Enum a => a -> Int
P.fromEnum NumberUpLayout
a) (NumberUpLayout -> Int
forall a. Enum a => a -> Int
P.fromEnum NumberUpLayout
b)
type instance O.ParentTypes NumberUpLayout = '[]
instance O.HasParentTypes NumberUpLayout
foreign import ccall "gtk_number_up_layout_get_type" c_gtk_number_up_layout_get_type ::
IO GType
instance B.Types.TypedObject NumberUpLayout where
glibType :: IO GType
glibType = IO GType
c_gtk_number_up_layout_get_type
instance B.Types.BoxedEnum NumberUpLayout
data NotebookTab =
NotebookTabFirst
| NotebookTabLast
| AnotherNotebookTab Int
deriving (Int -> NotebookTab -> ShowS
[NotebookTab] -> ShowS
NotebookTab -> String
(Int -> NotebookTab -> ShowS)
-> (NotebookTab -> String)
-> ([NotebookTab] -> ShowS)
-> Show NotebookTab
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NotebookTab] -> ShowS
$cshowList :: [NotebookTab] -> ShowS
show :: NotebookTab -> String
$cshow :: NotebookTab -> String
showsPrec :: Int -> NotebookTab -> ShowS
$cshowsPrec :: Int -> NotebookTab -> ShowS
Show, NotebookTab -> NotebookTab -> Bool
(NotebookTab -> NotebookTab -> Bool)
-> (NotebookTab -> NotebookTab -> Bool) -> Eq NotebookTab
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NotebookTab -> NotebookTab -> Bool
$c/= :: NotebookTab -> NotebookTab -> Bool
== :: NotebookTab -> NotebookTab -> Bool
$c== :: NotebookTab -> NotebookTab -> Bool
Eq)
instance P.Enum NotebookTab where
fromEnum :: NotebookTab -> Int
fromEnum NotebookTab
NotebookTabFirst = Int
0
fromEnum NotebookTab
NotebookTabLast = Int
1
fromEnum (AnotherNotebookTab Int
k) = Int
k
toEnum :: Int -> NotebookTab
toEnum Int
0 = NotebookTab
NotebookTabFirst
toEnum Int
1 = NotebookTab
NotebookTabLast
toEnum Int
k = Int -> NotebookTab
AnotherNotebookTab Int
k
instance P.Ord NotebookTab where
compare :: NotebookTab -> NotebookTab -> Ordering
compare NotebookTab
a NotebookTab
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (NotebookTab -> Int
forall a. Enum a => a -> Int
P.fromEnum NotebookTab
a) (NotebookTab -> Int
forall a. Enum a => a -> Int
P.fromEnum NotebookTab
b)
type instance O.ParentTypes NotebookTab = '[]
instance O.HasParentTypes NotebookTab
foreign import ccall "gtk_notebook_tab_get_type" c_gtk_notebook_tab_get_type ::
IO GType
instance B.Types.TypedObject NotebookTab where
glibType :: IO GType
glibType = IO GType
c_gtk_notebook_tab_get_type
instance B.Types.BoxedEnum NotebookTab
data MovementStep =
MovementStepLogicalPositions
| MovementStepVisualPositions
| MovementStepWords
| MovementStepDisplayLines
| MovementStepDisplayLineEnds
| MovementStepParagraphs
| MovementStepParagraphEnds
| MovementStepPages
| MovementStepBufferEnds
| MovementStepHorizontalPages
| AnotherMovementStep Int
deriving (Int -> MovementStep -> ShowS
[MovementStep] -> ShowS
MovementStep -> String
(Int -> MovementStep -> ShowS)
-> (MovementStep -> String)
-> ([MovementStep] -> ShowS)
-> Show MovementStep
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MovementStep] -> ShowS
$cshowList :: [MovementStep] -> ShowS
show :: MovementStep -> String
$cshow :: MovementStep -> String
showsPrec :: Int -> MovementStep -> ShowS
$cshowsPrec :: Int -> MovementStep -> ShowS
Show, MovementStep -> MovementStep -> Bool
(MovementStep -> MovementStep -> Bool)
-> (MovementStep -> MovementStep -> Bool) -> Eq MovementStep
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MovementStep -> MovementStep -> Bool
$c/= :: MovementStep -> MovementStep -> Bool
== :: MovementStep -> MovementStep -> Bool
$c== :: MovementStep -> MovementStep -> Bool
Eq)
instance P.Enum MovementStep where
fromEnum :: MovementStep -> Int
fromEnum MovementStep
MovementStepLogicalPositions = Int
0
fromEnum MovementStep
MovementStepVisualPositions = Int
1
fromEnum MovementStep
MovementStepWords = Int
2
fromEnum MovementStep
MovementStepDisplayLines = Int
3
fromEnum MovementStep
MovementStepDisplayLineEnds = Int
4
fromEnum MovementStep
MovementStepParagraphs = Int
5
fromEnum MovementStep
MovementStepParagraphEnds = Int
6
fromEnum MovementStep
MovementStepPages = Int
7
fromEnum MovementStep
MovementStepBufferEnds = Int
8
fromEnum MovementStep
MovementStepHorizontalPages = Int
9
fromEnum (AnotherMovementStep Int
k) = Int
k
toEnum :: Int -> MovementStep
toEnum Int
0 = MovementStep
MovementStepLogicalPositions
toEnum Int
1 = MovementStep
MovementStepVisualPositions
toEnum Int
2 = MovementStep
MovementStepWords
toEnum Int
3 = MovementStep
MovementStepDisplayLines
toEnum Int
4 = MovementStep
MovementStepDisplayLineEnds
toEnum Int
5 = MovementStep
MovementStepParagraphs
toEnum Int
6 = MovementStep
MovementStepParagraphEnds
toEnum Int
7 = MovementStep
MovementStepPages
toEnum Int
8 = MovementStep
MovementStepBufferEnds
toEnum Int
9 = MovementStep
MovementStepHorizontalPages
toEnum Int
k = Int -> MovementStep
AnotherMovementStep Int
k
instance P.Ord MovementStep where
compare :: MovementStep -> MovementStep -> Ordering
compare MovementStep
a MovementStep
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (MovementStep -> Int
forall a. Enum a => a -> Int
P.fromEnum MovementStep
a) (MovementStep -> Int
forall a. Enum a => a -> Int
P.fromEnum MovementStep
b)
type instance O.ParentTypes MovementStep = '[]
instance O.HasParentTypes MovementStep
foreign import ccall "gtk_movement_step_get_type" c_gtk_movement_step_get_type ::
IO GType
instance B.Types.TypedObject MovementStep where
glibType :: IO GType
glibType = IO GType
c_gtk_movement_step_get_type
instance B.Types.BoxedEnum MovementStep
data MessageType =
MessageTypeInfo
| MessageTypeWarning
| MessageTypeQuestion
| MessageTypeError
| MessageTypeOther
| AnotherMessageType Int
deriving (Int -> MessageType -> ShowS
[MessageType] -> ShowS
MessageType -> String
(Int -> MessageType -> ShowS)
-> (MessageType -> String)
-> ([MessageType] -> ShowS)
-> Show MessageType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MessageType] -> ShowS
$cshowList :: [MessageType] -> ShowS
show :: MessageType -> String
$cshow :: MessageType -> String
showsPrec :: Int -> MessageType -> ShowS
$cshowsPrec :: Int -> MessageType -> ShowS
Show, MessageType -> MessageType -> Bool
(MessageType -> MessageType -> Bool)
-> (MessageType -> MessageType -> Bool) -> Eq MessageType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MessageType -> MessageType -> Bool
$c/= :: MessageType -> MessageType -> Bool
== :: MessageType -> MessageType -> Bool
$c== :: MessageType -> MessageType -> Bool
Eq)
instance P.Enum MessageType where
fromEnum :: MessageType -> Int
fromEnum MessageType
MessageTypeInfo = Int
0
fromEnum MessageType
MessageTypeWarning = Int
1
fromEnum MessageType
MessageTypeQuestion = Int
2
fromEnum MessageType
MessageTypeError = Int
3
fromEnum MessageType
MessageTypeOther = Int
4
fromEnum (AnotherMessageType Int
k) = Int
k
toEnum :: Int -> MessageType
toEnum Int
0 = MessageType
MessageTypeInfo
toEnum Int
1 = MessageType
MessageTypeWarning
toEnum Int
2 = MessageType
MessageTypeQuestion
toEnum Int
3 = MessageType
MessageTypeError
toEnum Int
4 = MessageType
MessageTypeOther
toEnum Int
k = Int -> MessageType
AnotherMessageType Int
k
instance P.Ord MessageType where
compare :: MessageType -> MessageType -> Ordering
compare MessageType
a MessageType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (MessageType -> Int
forall a. Enum a => a -> Int
P.fromEnum MessageType
a) (MessageType -> Int
forall a. Enum a => a -> Int
P.fromEnum MessageType
b)
type instance O.ParentTypes MessageType = '[]
instance O.HasParentTypes MessageType
foreign import ccall "gtk_message_type_get_type" c_gtk_message_type_get_type ::
IO GType
instance B.Types.TypedObject MessageType where
glibType :: IO GType
glibType = IO GType
c_gtk_message_type_get_type
instance B.Types.BoxedEnum MessageType
data =
|
|
|
| Int
deriving (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
showList :: [MenuDirectionType] -> ShowS
$cshowList :: [MenuDirectionType] -> ShowS
show :: MenuDirectionType -> String
$cshow :: MenuDirectionType -> String
showsPrec :: Int -> MenuDirectionType -> ShowS
$cshowsPrec :: Int -> MenuDirectionType -> ShowS
Show, MenuDirectionType -> MenuDirectionType -> Bool
(MenuDirectionType -> MenuDirectionType -> Bool)
-> (MenuDirectionType -> MenuDirectionType -> Bool)
-> Eq MenuDirectionType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MenuDirectionType -> MenuDirectionType -> Bool
$c/= :: MenuDirectionType -> MenuDirectionType -> Bool
== :: MenuDirectionType -> MenuDirectionType -> Bool
$c== :: MenuDirectionType -> MenuDirectionType -> Bool
Eq)
instance P.Enum MenuDirectionType where
fromEnum :: MenuDirectionType -> Int
fromEnum MenuDirectionType
MenuDirectionTypeParent = Int
0
fromEnum MenuDirectionType
MenuDirectionTypeChild = Int
1
fromEnum MenuDirectionType
MenuDirectionTypeNext = Int
2
fromEnum MenuDirectionType
MenuDirectionTypePrev = Int
3
fromEnum (AnotherMenuDirectionType Int
k) = Int
k
toEnum :: Int -> MenuDirectionType
toEnum Int
0 = MenuDirectionType
MenuDirectionTypeParent
toEnum Int
1 = MenuDirectionType
MenuDirectionTypeChild
toEnum Int
2 = MenuDirectionType
MenuDirectionTypeNext
toEnum Int
3 = MenuDirectionType
MenuDirectionTypePrev
toEnum Int
k = Int -> MenuDirectionType
AnotherMenuDirectionType Int
k
instance P.Ord MenuDirectionType where
compare :: MenuDirectionType -> MenuDirectionType -> Ordering
compare MenuDirectionType
a MenuDirectionType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (MenuDirectionType -> Int
forall a. Enum a => a -> Int
P.fromEnum MenuDirectionType
a) (MenuDirectionType -> Int
forall a. Enum a => a -> Int
P.fromEnum MenuDirectionType
b)
type instance O.ParentTypes MenuDirectionType = '[]
instance O.HasParentTypes MenuDirectionType
foreign import ccall "gtk_menu_direction_type_get_type" ::
IO GType
instance B.Types.TypedObject MenuDirectionType where
glibType :: IO GType
glibType = IO GType
c_gtk_menu_direction_type_get_type
instance B.Types.BoxedEnum MenuDirectionType
data License =
LicenseUnknown
| LicenseCustom
| LicenseGpl20
| LicenseGpl30
| LicenseLgpl21
| LicenseLgpl30
| LicenseBsd
| LicenseMitX11
| LicenseArtistic
| LicenseGpl20Only
| LicenseGpl30Only
| LicenseLgpl21Only
| LicenseLgpl30Only
| LicenseAgpl30
| LicenseAgpl30Only
| LicenseBsd3
| LicenseApache20
| LicenseMpl20
| AnotherLicense Int
deriving (Int -> License -> ShowS
[License] -> ShowS
License -> String
(Int -> License -> ShowS)
-> (License -> String) -> ([License] -> ShowS) -> Show License
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [License] -> ShowS
$cshowList :: [License] -> ShowS
show :: License -> String
$cshow :: License -> String
showsPrec :: Int -> License -> ShowS
$cshowsPrec :: Int -> License -> ShowS
Show, License -> License -> Bool
(License -> License -> Bool)
-> (License -> License -> Bool) -> Eq License
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: License -> License -> Bool
$c/= :: License -> License -> Bool
== :: License -> License -> Bool
$c== :: License -> License -> Bool
Eq)
instance P.Enum License where
fromEnum :: License -> Int
fromEnum License
LicenseUnknown = Int
0
fromEnum License
LicenseCustom = Int
1
fromEnum License
LicenseGpl20 = Int
2
fromEnum License
LicenseGpl30 = Int
3
fromEnum License
LicenseLgpl21 = Int
4
fromEnum License
LicenseLgpl30 = Int
5
fromEnum License
LicenseBsd = Int
6
fromEnum License
LicenseMitX11 = Int
7
fromEnum License
LicenseArtistic = Int
8
fromEnum License
LicenseGpl20Only = Int
9
fromEnum License
LicenseGpl30Only = Int
10
fromEnum License
LicenseLgpl21Only = Int
11
fromEnum License
LicenseLgpl30Only = Int
12
fromEnum License
LicenseAgpl30 = Int
13
fromEnum License
LicenseAgpl30Only = Int
14
fromEnum License
LicenseBsd3 = Int
15
fromEnum License
LicenseApache20 = Int
16
fromEnum License
LicenseMpl20 = Int
17
fromEnum (AnotherLicense Int
k) = Int
k
toEnum :: Int -> License
toEnum Int
0 = License
LicenseUnknown
toEnum Int
1 = License
LicenseCustom
toEnum Int
2 = License
LicenseGpl20
toEnum Int
3 = License
LicenseGpl30
toEnum Int
4 = License
LicenseLgpl21
toEnum Int
5 = License
LicenseLgpl30
toEnum Int
6 = License
LicenseBsd
toEnum Int
7 = License
LicenseMitX11
toEnum Int
8 = License
LicenseArtistic
toEnum Int
9 = License
LicenseGpl20Only
toEnum Int
10 = License
LicenseGpl30Only
toEnum Int
11 = License
LicenseLgpl21Only
toEnum Int
12 = License
LicenseLgpl30Only
toEnum Int
13 = License
LicenseAgpl30
toEnum Int
14 = License
LicenseAgpl30Only
toEnum Int
15 = License
LicenseBsd3
toEnum Int
16 = License
LicenseApache20
toEnum Int
17 = License
LicenseMpl20
toEnum Int
k = Int -> License
AnotherLicense Int
k
instance P.Ord License where
compare :: License -> License -> Ordering
compare License
a License
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (License -> Int
forall a. Enum a => a -> Int
P.fromEnum License
a) (License -> Int
forall a. Enum a => a -> Int
P.fromEnum License
b)
type instance O.ParentTypes License = '[]
instance O.HasParentTypes License
foreign import ccall "gtk_license_get_type" c_gtk_license_get_type ::
IO GType
instance B.Types.TypedObject License where
glibType :: IO GType
glibType = IO GType
c_gtk_license_get_type
instance B.Types.BoxedEnum License
data LevelBarMode =
LevelBarModeContinuous
| LevelBarModeDiscrete
| AnotherLevelBarMode Int
deriving (Int -> LevelBarMode -> ShowS
[LevelBarMode] -> ShowS
LevelBarMode -> String
(Int -> LevelBarMode -> ShowS)
-> (LevelBarMode -> String)
-> ([LevelBarMode] -> ShowS)
-> Show LevelBarMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [LevelBarMode] -> ShowS
$cshowList :: [LevelBarMode] -> ShowS
show :: LevelBarMode -> String
$cshow :: LevelBarMode -> String
showsPrec :: Int -> LevelBarMode -> ShowS
$cshowsPrec :: Int -> LevelBarMode -> ShowS
Show, LevelBarMode -> LevelBarMode -> Bool
(LevelBarMode -> LevelBarMode -> Bool)
-> (LevelBarMode -> LevelBarMode -> Bool) -> Eq LevelBarMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: LevelBarMode -> LevelBarMode -> Bool
$c/= :: LevelBarMode -> LevelBarMode -> Bool
== :: LevelBarMode -> LevelBarMode -> Bool
$c== :: LevelBarMode -> LevelBarMode -> Bool
Eq)
instance P.Enum LevelBarMode where
fromEnum :: LevelBarMode -> Int
fromEnum LevelBarMode
LevelBarModeContinuous = Int
0
fromEnum LevelBarMode
LevelBarModeDiscrete = Int
1
fromEnum (AnotherLevelBarMode Int
k) = Int
k
toEnum :: Int -> LevelBarMode
toEnum Int
0 = LevelBarMode
LevelBarModeContinuous
toEnum Int
1 = LevelBarMode
LevelBarModeDiscrete
toEnum Int
k = Int -> LevelBarMode
AnotherLevelBarMode Int
k
instance P.Ord LevelBarMode where
compare :: LevelBarMode -> LevelBarMode -> Ordering
compare LevelBarMode
a LevelBarMode
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (LevelBarMode -> Int
forall a. Enum a => a -> Int
P.fromEnum LevelBarMode
a) (LevelBarMode -> Int
forall a. Enum a => a -> Int
P.fromEnum LevelBarMode
b)
type instance O.ParentTypes LevelBarMode = '[]
instance O.HasParentTypes LevelBarMode
foreign import ccall "gtk_level_bar_mode_get_type" c_gtk_level_bar_mode_get_type ::
IO GType
instance B.Types.TypedObject LevelBarMode where
glibType :: IO GType
glibType = IO GType
c_gtk_level_bar_mode_get_type
instance B.Types.BoxedEnum LevelBarMode
data Justification =
JustificationLeft
| JustificationRight
| JustificationCenter
| JustificationFill
| AnotherJustification Int
deriving (Int -> Justification -> ShowS
[Justification] -> ShowS
Justification -> String
(Int -> Justification -> ShowS)
-> (Justification -> String)
-> ([Justification] -> ShowS)
-> Show Justification
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Justification] -> ShowS
$cshowList :: [Justification] -> ShowS
show :: Justification -> String
$cshow :: Justification -> String
showsPrec :: Int -> Justification -> ShowS
$cshowsPrec :: Int -> Justification -> ShowS
Show, Justification -> Justification -> Bool
(Justification -> Justification -> Bool)
-> (Justification -> Justification -> Bool) -> Eq Justification
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Justification -> Justification -> Bool
$c/= :: Justification -> Justification -> Bool
== :: Justification -> Justification -> Bool
$c== :: Justification -> Justification -> Bool
Eq)
instance P.Enum Justification where
fromEnum :: Justification -> Int
fromEnum Justification
JustificationLeft = Int
0
fromEnum Justification
JustificationRight = Int
1
fromEnum Justification
JustificationCenter = Int
2
fromEnum Justification
JustificationFill = Int
3
fromEnum (AnotherJustification Int
k) = Int
k
toEnum :: Int -> Justification
toEnum Int
0 = Justification
JustificationLeft
toEnum Int
1 = Justification
JustificationRight
toEnum Int
2 = Justification
JustificationCenter
toEnum Int
3 = Justification
JustificationFill
toEnum Int
k = Int -> Justification
AnotherJustification Int
k
instance P.Ord Justification where
compare :: Justification -> Justification -> Ordering
compare Justification
a Justification
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (Justification -> Int
forall a. Enum a => a -> Int
P.fromEnum Justification
a) (Justification -> Int
forall a. Enum a => a -> Int
P.fromEnum Justification
b)
type instance O.ParentTypes Justification = '[]
instance O.HasParentTypes Justification
foreign import ccall "gtk_justification_get_type" c_gtk_justification_get_type ::
IO GType
instance B.Types.TypedObject Justification where
glibType :: IO GType
glibType = IO GType
c_gtk_justification_get_type
instance B.Types.BoxedEnum Justification
data InputPurpose =
InputPurposeFreeForm
| InputPurposeAlpha
| InputPurposeDigits
| InputPurposeNumber
| InputPurposePhone
| InputPurposeUrl
| InputPurposeEmail
| InputPurposeName
| InputPurposePassword
| InputPurposePin
| InputPurposeTerminal
| AnotherInputPurpose Int
deriving (Int -> InputPurpose -> ShowS
[InputPurpose] -> ShowS
InputPurpose -> String
(Int -> InputPurpose -> ShowS)
-> (InputPurpose -> String)
-> ([InputPurpose] -> ShowS)
-> Show InputPurpose
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [InputPurpose] -> ShowS
$cshowList :: [InputPurpose] -> ShowS
show :: InputPurpose -> String
$cshow :: InputPurpose -> String
showsPrec :: Int -> InputPurpose -> ShowS
$cshowsPrec :: Int -> InputPurpose -> ShowS
Show, InputPurpose -> InputPurpose -> Bool
(InputPurpose -> InputPurpose -> Bool)
-> (InputPurpose -> InputPurpose -> Bool) -> Eq InputPurpose
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: InputPurpose -> InputPurpose -> Bool
$c/= :: InputPurpose -> InputPurpose -> Bool
== :: InputPurpose -> InputPurpose -> Bool
$c== :: InputPurpose -> InputPurpose -> Bool
Eq)
instance P.Enum InputPurpose where
fromEnum :: InputPurpose -> Int
fromEnum InputPurpose
InputPurposeFreeForm = Int
0
fromEnum InputPurpose
InputPurposeAlpha = Int
1
fromEnum InputPurpose
InputPurposeDigits = Int
2
fromEnum InputPurpose
InputPurposeNumber = Int
3
fromEnum InputPurpose
InputPurposePhone = Int
4
fromEnum InputPurpose
InputPurposeUrl = Int
5
fromEnum InputPurpose
InputPurposeEmail = Int
6
fromEnum InputPurpose
InputPurposeName = Int
7
fromEnum InputPurpose
InputPurposePassword = Int
8
fromEnum InputPurpose
InputPurposePin = Int
9
fromEnum InputPurpose
InputPurposeTerminal = Int
10
fromEnum (AnotherInputPurpose Int
k) = Int
k
toEnum :: Int -> InputPurpose
toEnum Int
0 = InputPurpose
InputPurposeFreeForm
toEnum Int
1 = InputPurpose
InputPurposeAlpha
toEnum Int
2 = InputPurpose
InputPurposeDigits
toEnum Int
3 = InputPurpose
InputPurposeNumber
toEnum Int
4 = InputPurpose
InputPurposePhone
toEnum Int
5 = InputPurpose
InputPurposeUrl
toEnum Int
6 = InputPurpose
InputPurposeEmail
toEnum Int
7 = InputPurpose
InputPurposeName
toEnum Int
8 = InputPurpose
InputPurposePassword
toEnum Int
9 = InputPurpose
InputPurposePin
toEnum Int
10 = InputPurpose
InputPurposeTerminal
toEnum Int
k = Int -> InputPurpose
AnotherInputPurpose Int
k
instance P.Ord InputPurpose where
compare :: InputPurpose -> InputPurpose -> Ordering
compare InputPurpose
a InputPurpose
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (InputPurpose -> Int
forall a. Enum a => a -> Int
P.fromEnum InputPurpose
a) (InputPurpose -> Int
forall a. Enum a => a -> Int
P.fromEnum InputPurpose
b)
type instance O.ParentTypes InputPurpose = '[]
instance O.HasParentTypes InputPurpose
foreign import ccall "gtk_input_purpose_get_type" c_gtk_input_purpose_get_type ::
IO GType
instance B.Types.TypedObject InputPurpose where
glibType :: IO GType
glibType = IO GType
c_gtk_input_purpose_get_type
instance B.Types.BoxedEnum InputPurpose
data ImageType =
ImageTypeEmpty
| ImageTypePixbuf
| ImageTypeStock
| ImageTypeIconSet
| ImageTypeAnimation
| ImageTypeIconName
| ImageTypeGicon
| ImageTypeSurface
| AnotherImageType Int
deriving (Int -> ImageType -> ShowS
[ImageType] -> ShowS
ImageType -> String
(Int -> ImageType -> ShowS)
-> (ImageType -> String)
-> ([ImageType] -> ShowS)
-> Show ImageType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ImageType] -> ShowS
$cshowList :: [ImageType] -> ShowS
show :: ImageType -> String
$cshow :: ImageType -> String
showsPrec :: Int -> ImageType -> ShowS
$cshowsPrec :: Int -> ImageType -> ShowS
Show, ImageType -> ImageType -> Bool
(ImageType -> ImageType -> Bool)
-> (ImageType -> ImageType -> Bool) -> Eq ImageType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ImageType -> ImageType -> Bool
$c/= :: ImageType -> ImageType -> Bool
== :: ImageType -> ImageType -> Bool
$c== :: ImageType -> ImageType -> Bool
Eq)
instance P.Enum ImageType where
fromEnum :: ImageType -> Int
fromEnum ImageType
ImageTypeEmpty = Int
0
fromEnum ImageType
ImageTypePixbuf = Int
1
fromEnum ImageType
ImageTypeStock = Int
2
fromEnum ImageType
ImageTypeIconSet = Int
3
fromEnum ImageType
ImageTypeAnimation = Int
4
fromEnum ImageType
ImageTypeIconName = Int
5
fromEnum ImageType
ImageTypeGicon = Int
6
fromEnum ImageType
ImageTypeSurface = Int
7
fromEnum (AnotherImageType Int
k) = Int
k
toEnum :: Int -> ImageType
toEnum Int
0 = ImageType
ImageTypeEmpty
toEnum Int
1 = ImageType
ImageTypePixbuf
toEnum Int
2 = ImageType
ImageTypeStock
toEnum Int
3 = ImageType
ImageTypeIconSet
toEnum Int
4 = ImageType
ImageTypeAnimation
toEnum Int
5 = ImageType
ImageTypeIconName
toEnum Int
6 = ImageType
ImageTypeGicon
toEnum Int
7 = ImageType
ImageTypeSurface
toEnum Int
k = Int -> ImageType
AnotherImageType Int
k
instance P.Ord ImageType where
compare :: ImageType -> ImageType -> Ordering
compare ImageType
a ImageType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ImageType -> Int
forall a. Enum a => a -> Int
P.fromEnum ImageType
a) (ImageType -> Int
forall a. Enum a => a -> Int
P.fromEnum ImageType
b)
type instance O.ParentTypes ImageType = '[]
instance O.HasParentTypes ImageType
foreign import ccall "gtk_image_type_get_type" c_gtk_image_type_get_type ::
IO GType
instance B.Types.TypedObject ImageType where
glibType :: IO GType
glibType = IO GType
c_gtk_image_type_get_type
instance B.Types.BoxedEnum ImageType
data IconViewDropPosition =
IconViewDropPositionNoDrop
| IconViewDropPositionDropInto
| IconViewDropPositionDropLeft
| IconViewDropPositionDropRight
| IconViewDropPositionDropAbove
| IconViewDropPositionDropBelow
| AnotherIconViewDropPosition Int
deriving (Int -> IconViewDropPosition -> ShowS
[IconViewDropPosition] -> ShowS
IconViewDropPosition -> String
(Int -> IconViewDropPosition -> ShowS)
-> (IconViewDropPosition -> String)
-> ([IconViewDropPosition] -> ShowS)
-> Show IconViewDropPosition
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [IconViewDropPosition] -> ShowS
$cshowList :: [IconViewDropPosition] -> ShowS
show :: IconViewDropPosition -> String
$cshow :: IconViewDropPosition -> String
showsPrec :: Int -> IconViewDropPosition -> ShowS
$cshowsPrec :: Int -> IconViewDropPosition -> ShowS
Show, IconViewDropPosition -> IconViewDropPosition -> Bool
(IconViewDropPosition -> IconViewDropPosition -> Bool)
-> (IconViewDropPosition -> IconViewDropPosition -> Bool)
-> Eq IconViewDropPosition
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: IconViewDropPosition -> IconViewDropPosition -> Bool
$c/= :: IconViewDropPosition -> IconViewDropPosition -> Bool
== :: IconViewDropPosition -> IconViewDropPosition -> Bool
$c== :: IconViewDropPosition -> IconViewDropPosition -> Bool
Eq)
instance P.Enum IconViewDropPosition where
fromEnum :: IconViewDropPosition -> Int
fromEnum IconViewDropPosition
IconViewDropPositionNoDrop = Int
0
fromEnum IconViewDropPosition
IconViewDropPositionDropInto = Int
1
fromEnum IconViewDropPosition
IconViewDropPositionDropLeft = Int
2
fromEnum IconViewDropPosition
IconViewDropPositionDropRight = Int
3
fromEnum IconViewDropPosition
IconViewDropPositionDropAbove = Int
4
fromEnum IconViewDropPosition
IconViewDropPositionDropBelow = Int
5
fromEnum (AnotherIconViewDropPosition Int
k) = Int
k
toEnum :: Int -> IconViewDropPosition
toEnum Int
0 = IconViewDropPosition
IconViewDropPositionNoDrop
toEnum Int
1 = IconViewDropPosition
IconViewDropPositionDropInto
toEnum Int
2 = IconViewDropPosition
IconViewDropPositionDropLeft
toEnum Int
3 = IconViewDropPosition
IconViewDropPositionDropRight
toEnum Int
4 = IconViewDropPosition
IconViewDropPositionDropAbove
toEnum Int
5 = IconViewDropPosition
IconViewDropPositionDropBelow
toEnum Int
k = Int -> IconViewDropPosition
AnotherIconViewDropPosition Int
k
instance P.Ord IconViewDropPosition where
compare :: IconViewDropPosition -> IconViewDropPosition -> Ordering
compare IconViewDropPosition
a IconViewDropPosition
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (IconViewDropPosition -> Int
forall a. Enum a => a -> Int
P.fromEnum IconViewDropPosition
a) (IconViewDropPosition -> Int
forall a. Enum a => a -> Int
P.fromEnum IconViewDropPosition
b)
type instance O.ParentTypes IconViewDropPosition = '[]
instance O.HasParentTypes IconViewDropPosition
foreign import ccall "gtk_icon_view_drop_position_get_type" c_gtk_icon_view_drop_position_get_type ::
IO GType
instance B.Types.TypedObject IconViewDropPosition where
glibType :: IO GType
glibType = IO GType
c_gtk_icon_view_drop_position_get_type
instance B.Types.BoxedEnum IconViewDropPosition
data IconThemeError =
IconThemeErrorNotFound
| IconThemeErrorFailed
| AnotherIconThemeError Int
deriving (Int -> IconThemeError -> ShowS
[IconThemeError] -> ShowS
IconThemeError -> String
(Int -> IconThemeError -> ShowS)
-> (IconThemeError -> String)
-> ([IconThemeError] -> ShowS)
-> Show IconThemeError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [IconThemeError] -> ShowS
$cshowList :: [IconThemeError] -> ShowS
show :: IconThemeError -> String
$cshow :: IconThemeError -> String
showsPrec :: Int -> IconThemeError -> ShowS
$cshowsPrec :: Int -> IconThemeError -> ShowS
Show, IconThemeError -> IconThemeError -> Bool
(IconThemeError -> IconThemeError -> Bool)
-> (IconThemeError -> IconThemeError -> Bool) -> Eq IconThemeError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: IconThemeError -> IconThemeError -> Bool
$c/= :: IconThemeError -> IconThemeError -> Bool
== :: IconThemeError -> IconThemeError -> Bool
$c== :: IconThemeError -> IconThemeError -> Bool
Eq)
instance P.Enum IconThemeError where
fromEnum :: IconThemeError -> Int
fromEnum IconThemeError
IconThemeErrorNotFound = Int
0
fromEnum IconThemeError
IconThemeErrorFailed = Int
1
fromEnum (AnotherIconThemeError Int
k) = Int
k
toEnum :: Int -> IconThemeError
toEnum Int
0 = IconThemeError
IconThemeErrorNotFound
toEnum Int
1 = IconThemeError
IconThemeErrorFailed
toEnum Int
k = Int -> IconThemeError
AnotherIconThemeError Int
k
instance P.Ord IconThemeError where
compare :: IconThemeError -> IconThemeError -> Ordering
compare IconThemeError
a IconThemeError
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (IconThemeError -> Int
forall a. Enum a => a -> Int
P.fromEnum IconThemeError
a) (IconThemeError -> Int
forall a. Enum a => a -> Int
P.fromEnum IconThemeError
b)
instance GErrorClass IconThemeError where
gerrorClassDomain :: IconThemeError -> Text
gerrorClassDomain IconThemeError
_ = Text
"gtk-icon-theme-error-quark"
catchIconThemeError ::
IO a ->
(IconThemeError -> GErrorMessage -> IO a) ->
IO a
catchIconThemeError :: forall a. IO a -> (IconThemeError -> Text -> IO a) -> IO a
catchIconThemeError = IO a -> (IconThemeError -> Text -> IO a) -> IO a
forall err a.
GErrorClass err =>
IO a -> (err -> Text -> IO a) -> IO a
catchGErrorJustDomain
handleIconThemeError ::
(IconThemeError -> GErrorMessage -> IO a) ->
IO a ->
IO a
handleIconThemeError :: forall a. (IconThemeError -> Text -> IO a) -> IO a -> IO a
handleIconThemeError = (IconThemeError -> Text -> IO a) -> IO a -> IO a
forall err a.
GErrorClass err =>
(err -> Text -> IO a) -> IO a -> IO a
handleGErrorJustDomain
type instance O.ParentTypes IconThemeError = '[]
instance O.HasParentTypes IconThemeError
foreign import ccall "gtk_icon_theme_error_get_type" c_gtk_icon_theme_error_get_type ::
IO GType
instance B.Types.TypedObject IconThemeError where
glibType :: IO GType
glibType = IO GType
c_gtk_icon_theme_error_get_type
instance B.Types.BoxedEnum IconThemeError
data IconSize =
IconSizeInvalid
|
| IconSizeSmallToolbar
| IconSizeLargeToolbar
| IconSizeButton
| IconSizeDnd
| IconSizeDialog
| AnotherIconSize Int
deriving (Int -> IconSize -> ShowS
[IconSize] -> ShowS
IconSize -> String
(Int -> IconSize -> ShowS)
-> (IconSize -> String) -> ([IconSize] -> ShowS) -> Show IconSize
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [IconSize] -> ShowS
$cshowList :: [IconSize] -> ShowS
show :: IconSize -> String
$cshow :: IconSize -> String
showsPrec :: Int -> IconSize -> ShowS
$cshowsPrec :: Int -> IconSize -> ShowS
Show, IconSize -> IconSize -> Bool
(IconSize -> IconSize -> Bool)
-> (IconSize -> IconSize -> Bool) -> Eq IconSize
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: IconSize -> IconSize -> Bool
$c/= :: IconSize -> IconSize -> Bool
== :: IconSize -> IconSize -> Bool
$c== :: IconSize -> IconSize -> Bool
Eq)
instance P.Enum IconSize where
fromEnum :: IconSize -> Int
fromEnum IconSize
IconSizeInvalid = Int
0
fromEnum IconSize
IconSizeMenu = Int
1
fromEnum IconSize
IconSizeSmallToolbar = Int
2
fromEnum IconSize
IconSizeLargeToolbar = Int
3
fromEnum IconSize
IconSizeButton = Int
4
fromEnum IconSize
IconSizeDnd = Int
5
fromEnum IconSize
IconSizeDialog = Int
6
fromEnum (AnotherIconSize Int
k) = Int
k
toEnum :: Int -> IconSize
toEnum Int
0 = IconSize
IconSizeInvalid
toEnum Int
1 = IconSize
IconSizeMenu
toEnum Int
2 = IconSize
IconSizeSmallToolbar
toEnum Int
3 = IconSize
IconSizeLargeToolbar
toEnum Int
4 = IconSize
IconSizeButton
toEnum Int
5 = IconSize
IconSizeDnd
toEnum Int
6 = IconSize
IconSizeDialog
toEnum Int
k = Int -> IconSize
AnotherIconSize Int
k
instance P.Ord IconSize where
compare :: IconSize -> IconSize -> Ordering
compare IconSize
a IconSize
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (IconSize -> Int
forall a. Enum a => a -> Int
P.fromEnum IconSize
a) (IconSize -> Int
forall a. Enum a => a -> Int
P.fromEnum IconSize
b)
type instance O.ParentTypes IconSize = '[]
instance O.HasParentTypes IconSize
foreign import ccall "gtk_icon_size_get_type" c_gtk_icon_size_get_type ::
IO GType
instance B.Types.TypedObject IconSize where
glibType :: IO GType
glibType = IO GType
c_gtk_icon_size_get_type
instance B.Types.BoxedEnum IconSize
{-# DEPRECATED IMStatusStyle ["(Since version 3.10)"] #-}
data IMStatusStyle =
IMStatusStyleNothing
| IMStatusStyleCallback
| IMStatusStyleNone
| AnotherIMStatusStyle Int
deriving (Int -> IMStatusStyle -> ShowS
[IMStatusStyle] -> ShowS
IMStatusStyle -> String
(Int -> IMStatusStyle -> ShowS)
-> (IMStatusStyle -> String)
-> ([IMStatusStyle] -> ShowS)
-> Show IMStatusStyle
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [IMStatusStyle] -> ShowS
$cshowList :: [IMStatusStyle] -> ShowS
show :: IMStatusStyle -> String
$cshow :: IMStatusStyle -> String
showsPrec :: Int -> IMStatusStyle -> ShowS
$cshowsPrec :: Int -> IMStatusStyle -> ShowS
Show, IMStatusStyle -> IMStatusStyle -> Bool
(IMStatusStyle -> IMStatusStyle -> Bool)
-> (IMStatusStyle -> IMStatusStyle -> Bool) -> Eq IMStatusStyle
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: IMStatusStyle -> IMStatusStyle -> Bool
$c/= :: IMStatusStyle -> IMStatusStyle -> Bool
== :: IMStatusStyle -> IMStatusStyle -> Bool
$c== :: IMStatusStyle -> IMStatusStyle -> Bool
Eq)
instance P.Enum IMStatusStyle where
fromEnum :: IMStatusStyle -> Int
fromEnum IMStatusStyle
IMStatusStyleNothing = Int
0
fromEnum IMStatusStyle
IMStatusStyleCallback = Int
1
fromEnum IMStatusStyle
IMStatusStyleNone = Int
2
fromEnum (AnotherIMStatusStyle Int
k) = Int
k
toEnum :: Int -> IMStatusStyle
toEnum Int
0 = IMStatusStyle
IMStatusStyleNothing
toEnum Int
1 = IMStatusStyle
IMStatusStyleCallback
toEnum Int
2 = IMStatusStyle
IMStatusStyleNone
toEnum Int
k = Int -> IMStatusStyle
AnotherIMStatusStyle Int
k
instance P.Ord IMStatusStyle where
compare :: IMStatusStyle -> IMStatusStyle -> Ordering
compare IMStatusStyle
a IMStatusStyle
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (IMStatusStyle -> Int
forall a. Enum a => a -> Int
P.fromEnum IMStatusStyle
a) (IMStatusStyle -> Int
forall a. Enum a => a -> Int
P.fromEnum IMStatusStyle
b)
type instance O.ParentTypes IMStatusStyle = '[]
instance O.HasParentTypes IMStatusStyle
foreign import ccall "gtk_im_status_style_get_type" c_gtk_im_status_style_get_type ::
IO GType
instance B.Types.TypedObject IMStatusStyle where
glibType :: IO GType
glibType = IO GType
c_gtk_im_status_style_get_type
instance B.Types.BoxedEnum IMStatusStyle
{-# DEPRECATED IMPreeditStyle ["(Since version 3.10)"] #-}
data IMPreeditStyle =
IMPreeditStyleNothing
| IMPreeditStyleCallback
| IMPreeditStyleNone
| AnotherIMPreeditStyle Int
deriving (Int -> IMPreeditStyle -> ShowS
[IMPreeditStyle] -> ShowS
IMPreeditStyle -> String
(Int -> IMPreeditStyle -> ShowS)
-> (IMPreeditStyle -> String)
-> ([IMPreeditStyle] -> ShowS)
-> Show IMPreeditStyle
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [IMPreeditStyle] -> ShowS
$cshowList :: [IMPreeditStyle] -> ShowS
show :: IMPreeditStyle -> String
$cshow :: IMPreeditStyle -> String
showsPrec :: Int -> IMPreeditStyle -> ShowS
$cshowsPrec :: Int -> IMPreeditStyle -> ShowS
Show, IMPreeditStyle -> IMPreeditStyle -> Bool
(IMPreeditStyle -> IMPreeditStyle -> Bool)
-> (IMPreeditStyle -> IMPreeditStyle -> Bool) -> Eq IMPreeditStyle
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: IMPreeditStyle -> IMPreeditStyle -> Bool
$c/= :: IMPreeditStyle -> IMPreeditStyle -> Bool
== :: IMPreeditStyle -> IMPreeditStyle -> Bool
$c== :: IMPreeditStyle -> IMPreeditStyle -> Bool
Eq)
instance P.Enum IMPreeditStyle where
fromEnum :: IMPreeditStyle -> Int
fromEnum IMPreeditStyle
IMPreeditStyleNothing = Int
0
fromEnum IMPreeditStyle
IMPreeditStyleCallback = Int
1
fromEnum IMPreeditStyle
IMPreeditStyleNone = Int
2
fromEnum (AnotherIMPreeditStyle Int
k) = Int
k
toEnum :: Int -> IMPreeditStyle
toEnum Int
0 = IMPreeditStyle
IMPreeditStyleNothing
toEnum Int
1 = IMPreeditStyle
IMPreeditStyleCallback
toEnum Int
2 = IMPreeditStyle
IMPreeditStyleNone
toEnum Int
k = Int -> IMPreeditStyle
AnotherIMPreeditStyle Int
k
instance P.Ord IMPreeditStyle where
compare :: IMPreeditStyle -> IMPreeditStyle -> Ordering
compare IMPreeditStyle
a IMPreeditStyle
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (IMPreeditStyle -> Int
forall a. Enum a => a -> Int
P.fromEnum IMPreeditStyle
a) (IMPreeditStyle -> Int
forall a. Enum a => a -> Int
P.fromEnum IMPreeditStyle
b)
type instance O.ParentTypes IMPreeditStyle = '[]
instance O.HasParentTypes IMPreeditStyle
foreign import ccall "gtk_im_preedit_style_get_type" c_gtk_im_preedit_style_get_type ::
IO GType
instance B.Types.TypedObject IMPreeditStyle where
glibType :: IO GType
glibType = IO GType
c_gtk_im_preedit_style_get_type
instance B.Types.BoxedEnum IMPreeditStyle
data FileChooserError =
FileChooserErrorNonexistent
| FileChooserErrorBadFilename
| FileChooserErrorAlreadyExists
| FileChooserErrorIncompleteHostname
| AnotherFileChooserError Int
deriving (Int -> FileChooserError -> ShowS
[FileChooserError] -> ShowS
FileChooserError -> String
(Int -> FileChooserError -> ShowS)
-> (FileChooserError -> String)
-> ([FileChooserError] -> ShowS)
-> Show FileChooserError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FileChooserError] -> ShowS
$cshowList :: [FileChooserError] -> ShowS
show :: FileChooserError -> String
$cshow :: FileChooserError -> String
showsPrec :: Int -> FileChooserError -> ShowS
$cshowsPrec :: Int -> FileChooserError -> ShowS
Show, FileChooserError -> FileChooserError -> Bool
(FileChooserError -> FileChooserError -> Bool)
-> (FileChooserError -> FileChooserError -> Bool)
-> Eq FileChooserError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FileChooserError -> FileChooserError -> Bool
$c/= :: FileChooserError -> FileChooserError -> Bool
== :: FileChooserError -> FileChooserError -> Bool
$c== :: FileChooserError -> FileChooserError -> Bool
Eq)
instance P.Enum FileChooserError where
fromEnum :: FileChooserError -> Int
fromEnum FileChooserError
FileChooserErrorNonexistent = Int
0
fromEnum FileChooserError
FileChooserErrorBadFilename = Int
1
fromEnum FileChooserError
FileChooserErrorAlreadyExists = Int
2
fromEnum FileChooserError
FileChooserErrorIncompleteHostname = Int
3
fromEnum (AnotherFileChooserError Int
k) = Int
k
toEnum :: Int -> FileChooserError
toEnum Int
0 = FileChooserError
FileChooserErrorNonexistent
toEnum Int
1 = FileChooserError
FileChooserErrorBadFilename
toEnum Int
2 = FileChooserError
FileChooserErrorAlreadyExists
toEnum Int
3 = FileChooserError
FileChooserErrorIncompleteHostname
toEnum Int
k = Int -> FileChooserError
AnotherFileChooserError Int
k
instance P.Ord FileChooserError where
compare :: FileChooserError -> FileChooserError -> Ordering
compare FileChooserError
a FileChooserError
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (FileChooserError -> Int
forall a. Enum a => a -> Int
P.fromEnum FileChooserError
a) (FileChooserError -> Int
forall a. Enum a => a -> Int
P.fromEnum FileChooserError
b)
instance GErrorClass FileChooserError where
gerrorClassDomain :: FileChooserError -> Text
gerrorClassDomain FileChooserError
_ = Text
"gtk-file-chooser-error-quark"
catchFileChooserError ::
IO a ->
(FileChooserError -> GErrorMessage -> IO a) ->
IO a
catchFileChooserError :: forall a. IO a -> (FileChooserError -> Text -> IO a) -> IO a
catchFileChooserError = IO a -> (FileChooserError -> Text -> IO a) -> IO a
forall err a.
GErrorClass err =>
IO a -> (err -> Text -> IO a) -> IO a
catchGErrorJustDomain
handleFileChooserError ::
(FileChooserError -> GErrorMessage -> IO a) ->
IO a ->
IO a
handleFileChooserError :: forall a. (FileChooserError -> Text -> IO a) -> IO a -> IO a
handleFileChooserError = (FileChooserError -> Text -> IO a) -> IO a -> IO a
forall err a.
GErrorClass err =>
(err -> Text -> IO a) -> IO a -> IO a
handleGErrorJustDomain
type instance O.ParentTypes FileChooserError = '[]
instance O.HasParentTypes FileChooserError
foreign import ccall "gtk_file_chooser_error_get_type" c_gtk_file_chooser_error_get_type ::
IO GType
instance B.Types.TypedObject FileChooserError where
glibType :: IO GType
glibType = IO GType
c_gtk_file_chooser_error_get_type
instance B.Types.BoxedEnum FileChooserError
data FileChooserConfirmation =
FileChooserConfirmationConfirm
| FileChooserConfirmationAcceptFilename
| FileChooserConfirmationSelectAgain
| AnotherFileChooserConfirmation Int
deriving (Int -> FileChooserConfirmation -> ShowS
[FileChooserConfirmation] -> ShowS
FileChooserConfirmation -> String
(Int -> FileChooserConfirmation -> ShowS)
-> (FileChooserConfirmation -> String)
-> ([FileChooserConfirmation] -> ShowS)
-> Show FileChooserConfirmation
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FileChooserConfirmation] -> ShowS
$cshowList :: [FileChooserConfirmation] -> ShowS
show :: FileChooserConfirmation -> String
$cshow :: FileChooserConfirmation -> String
showsPrec :: Int -> FileChooserConfirmation -> ShowS
$cshowsPrec :: Int -> FileChooserConfirmation -> ShowS
Show, FileChooserConfirmation -> FileChooserConfirmation -> Bool
(FileChooserConfirmation -> FileChooserConfirmation -> Bool)
-> (FileChooserConfirmation -> FileChooserConfirmation -> Bool)
-> Eq FileChooserConfirmation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FileChooserConfirmation -> FileChooserConfirmation -> Bool
$c/= :: FileChooserConfirmation -> FileChooserConfirmation -> Bool
== :: FileChooserConfirmation -> FileChooserConfirmation -> Bool
$c== :: FileChooserConfirmation -> FileChooserConfirmation -> Bool
Eq)
instance P.Enum FileChooserConfirmation where
fromEnum :: FileChooserConfirmation -> Int
fromEnum FileChooserConfirmation
FileChooserConfirmationConfirm = Int
0
fromEnum FileChooserConfirmation
FileChooserConfirmationAcceptFilename = Int
1
fromEnum FileChooserConfirmation
FileChooserConfirmationSelectAgain = Int
2
fromEnum (AnotherFileChooserConfirmation Int
k) = Int
k
toEnum :: Int -> FileChooserConfirmation
toEnum Int
0 = FileChooserConfirmation
FileChooserConfirmationConfirm
toEnum Int
1 = FileChooserConfirmation
FileChooserConfirmationAcceptFilename
toEnum Int
2 = FileChooserConfirmation
FileChooserConfirmationSelectAgain
toEnum Int
k = Int -> FileChooserConfirmation
AnotherFileChooserConfirmation Int
k
instance P.Ord FileChooserConfirmation where
compare :: FileChooserConfirmation -> FileChooserConfirmation -> Ordering
compare FileChooserConfirmation
a FileChooserConfirmation
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (FileChooserConfirmation -> Int
forall a. Enum a => a -> Int
P.fromEnum FileChooserConfirmation
a) (FileChooserConfirmation -> Int
forall a. Enum a => a -> Int
P.fromEnum FileChooserConfirmation
b)
type instance O.ParentTypes FileChooserConfirmation = '[]
instance O.HasParentTypes FileChooserConfirmation
foreign import ccall "gtk_file_chooser_confirmation_get_type" c_gtk_file_chooser_confirmation_get_type ::
IO GType
instance B.Types.TypedObject FileChooserConfirmation where
glibType :: IO GType
glibType = IO GType
c_gtk_file_chooser_confirmation_get_type
instance B.Types.BoxedEnum FileChooserConfirmation
data FileChooserAction =
FileChooserActionOpen
| FileChooserActionSave
| FileChooserActionSelectFolder
| FileChooserActionCreateFolder
| AnotherFileChooserAction Int
deriving (Int -> FileChooserAction -> ShowS
[FileChooserAction] -> ShowS
FileChooserAction -> String
(Int -> FileChooserAction -> ShowS)
-> (FileChooserAction -> String)
-> ([FileChooserAction] -> ShowS)
-> Show FileChooserAction
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FileChooserAction] -> ShowS
$cshowList :: [FileChooserAction] -> ShowS
show :: FileChooserAction -> String
$cshow :: FileChooserAction -> String
showsPrec :: Int -> FileChooserAction -> ShowS
$cshowsPrec :: Int -> FileChooserAction -> ShowS
Show, FileChooserAction -> FileChooserAction -> Bool
(FileChooserAction -> FileChooserAction -> Bool)
-> (FileChooserAction -> FileChooserAction -> Bool)
-> Eq FileChooserAction
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FileChooserAction -> FileChooserAction -> Bool
$c/= :: FileChooserAction -> FileChooserAction -> Bool
== :: FileChooserAction -> FileChooserAction -> Bool
$c== :: FileChooserAction -> FileChooserAction -> Bool
Eq)
instance P.Enum FileChooserAction where
fromEnum :: FileChooserAction -> Int
fromEnum FileChooserAction
FileChooserActionOpen = Int
0
fromEnum FileChooserAction
FileChooserActionSave = Int
1
fromEnum FileChooserAction
FileChooserActionSelectFolder = Int
2
fromEnum FileChooserAction
FileChooserActionCreateFolder = Int
3
fromEnum (AnotherFileChooserAction Int
k) = Int
k
toEnum :: Int -> FileChooserAction
toEnum Int
0 = FileChooserAction
FileChooserActionOpen
toEnum Int
1 = FileChooserAction
FileChooserActionSave
toEnum Int
2 = FileChooserAction
FileChooserActionSelectFolder
toEnum Int
3 = FileChooserAction
FileChooserActionCreateFolder
toEnum Int
k = Int -> FileChooserAction
AnotherFileChooserAction Int
k
instance P.Ord FileChooserAction where
compare :: FileChooserAction -> FileChooserAction -> Ordering
compare FileChooserAction
a FileChooserAction
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (FileChooserAction -> Int
forall a. Enum a => a -> Int
P.fromEnum FileChooserAction
a) (FileChooserAction -> Int
forall a. Enum a => a -> Int
P.fromEnum FileChooserAction
b)
type instance O.ParentTypes FileChooserAction = '[]
instance O.HasParentTypes FileChooserAction
foreign import ccall "gtk_file_chooser_action_get_type" c_gtk_file_chooser_action_get_type ::
IO GType
instance B.Types.TypedObject FileChooserAction where
glibType :: IO GType
glibType = IO GType
c_gtk_file_chooser_action_get_type
instance B.Types.BoxedEnum FileChooserAction
data ExpanderStyle =
ExpanderStyleCollapsed
| ExpanderStyleSemiCollapsed
| ExpanderStyleSemiExpanded
| ExpanderStyleExpanded
| AnotherExpanderStyle Int
deriving (Int -> ExpanderStyle -> ShowS
[ExpanderStyle] -> ShowS
ExpanderStyle -> String
(Int -> ExpanderStyle -> ShowS)
-> (ExpanderStyle -> String)
-> ([ExpanderStyle] -> ShowS)
-> Show ExpanderStyle
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ExpanderStyle] -> ShowS
$cshowList :: [ExpanderStyle] -> ShowS
show :: ExpanderStyle -> String
$cshow :: ExpanderStyle -> String
showsPrec :: Int -> ExpanderStyle -> ShowS
$cshowsPrec :: Int -> ExpanderStyle -> ShowS
Show, ExpanderStyle -> ExpanderStyle -> Bool
(ExpanderStyle -> ExpanderStyle -> Bool)
-> (ExpanderStyle -> ExpanderStyle -> Bool) -> Eq ExpanderStyle
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ExpanderStyle -> ExpanderStyle -> Bool
$c/= :: ExpanderStyle -> ExpanderStyle -> Bool
== :: ExpanderStyle -> ExpanderStyle -> Bool
$c== :: ExpanderStyle -> ExpanderStyle -> Bool
Eq)
instance P.Enum ExpanderStyle where
fromEnum :: ExpanderStyle -> Int
fromEnum ExpanderStyle
ExpanderStyleCollapsed = Int
0
fromEnum ExpanderStyle
ExpanderStyleSemiCollapsed = Int
1
fromEnum ExpanderStyle
ExpanderStyleSemiExpanded = Int
2
fromEnum ExpanderStyle
ExpanderStyleExpanded = Int
3
fromEnum (AnotherExpanderStyle Int
k) = Int
k
toEnum :: Int -> ExpanderStyle
toEnum Int
0 = ExpanderStyle
ExpanderStyleCollapsed
toEnum Int
1 = ExpanderStyle
ExpanderStyleSemiCollapsed
toEnum Int
2 = ExpanderStyle
ExpanderStyleSemiExpanded
toEnum Int
3 = ExpanderStyle
ExpanderStyleExpanded
toEnum Int
k = Int -> ExpanderStyle
AnotherExpanderStyle Int
k
instance P.Ord ExpanderStyle where
compare :: ExpanderStyle -> ExpanderStyle -> Ordering
compare ExpanderStyle
a ExpanderStyle
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ExpanderStyle -> Int
forall a. Enum a => a -> Int
P.fromEnum ExpanderStyle
a) (ExpanderStyle -> Int
forall a. Enum a => a -> Int
P.fromEnum ExpanderStyle
b)
type instance O.ParentTypes ExpanderStyle = '[]
instance O.HasParentTypes ExpanderStyle
foreign import ccall "gtk_expander_style_get_type" c_gtk_expander_style_get_type ::
IO GType
instance B.Types.TypedObject ExpanderStyle where
glibType :: IO GType
glibType = IO GType
c_gtk_expander_style_get_type
instance B.Types.BoxedEnum ExpanderStyle
data EventSequenceState =
EventSequenceStateNone
| EventSequenceStateClaimed
| EventSequenceStateDenied
| AnotherEventSequenceState Int
deriving (Int -> EventSequenceState -> ShowS
[EventSequenceState] -> ShowS
EventSequenceState -> String
(Int -> EventSequenceState -> ShowS)
-> (EventSequenceState -> String)
-> ([EventSequenceState] -> ShowS)
-> Show EventSequenceState
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [EventSequenceState] -> ShowS
$cshowList :: [EventSequenceState] -> ShowS
show :: EventSequenceState -> String
$cshow :: EventSequenceState -> String
showsPrec :: Int -> EventSequenceState -> ShowS
$cshowsPrec :: Int -> EventSequenceState -> ShowS
Show, EventSequenceState -> EventSequenceState -> Bool
(EventSequenceState -> EventSequenceState -> Bool)
-> (EventSequenceState -> EventSequenceState -> Bool)
-> Eq EventSequenceState
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: EventSequenceState -> EventSequenceState -> Bool
$c/= :: EventSequenceState -> EventSequenceState -> Bool
== :: EventSequenceState -> EventSequenceState -> Bool
$c== :: EventSequenceState -> EventSequenceState -> Bool
Eq)
instance P.Enum EventSequenceState where
fromEnum :: EventSequenceState -> Int
fromEnum EventSequenceState
EventSequenceStateNone = Int
0
fromEnum EventSequenceState
EventSequenceStateClaimed = Int
1
fromEnum EventSequenceState
EventSequenceStateDenied = Int
2
fromEnum (AnotherEventSequenceState Int
k) = Int
k
toEnum :: Int -> EventSequenceState
toEnum Int
0 = EventSequenceState
EventSequenceStateNone
toEnum Int
1 = EventSequenceState
EventSequenceStateClaimed
toEnum Int
2 = EventSequenceState
EventSequenceStateDenied
toEnum Int
k = Int -> EventSequenceState
AnotherEventSequenceState Int
k
instance P.Ord EventSequenceState where
compare :: EventSequenceState -> EventSequenceState -> Ordering
compare EventSequenceState
a EventSequenceState
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (EventSequenceState -> Int
forall a. Enum a => a -> Int
P.fromEnum EventSequenceState
a) (EventSequenceState -> Int
forall a. Enum a => a -> Int
P.fromEnum EventSequenceState
b)
type instance O.ParentTypes EventSequenceState = '[]
instance O.HasParentTypes EventSequenceState
foreign import ccall "gtk_event_sequence_state_get_type" c_gtk_event_sequence_state_get_type ::
IO GType
instance B.Types.TypedObject EventSequenceState where
glibType :: IO GType
glibType = IO GType
c_gtk_event_sequence_state_get_type
instance B.Types.BoxedEnum EventSequenceState
data EntryIconPosition =
EntryIconPositionPrimary
| EntryIconPositionSecondary
| AnotherEntryIconPosition Int
deriving (Int -> EntryIconPosition -> ShowS
[EntryIconPosition] -> ShowS
EntryIconPosition -> String
(Int -> EntryIconPosition -> ShowS)
-> (EntryIconPosition -> String)
-> ([EntryIconPosition] -> ShowS)
-> Show EntryIconPosition
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [EntryIconPosition] -> ShowS
$cshowList :: [EntryIconPosition] -> ShowS
show :: EntryIconPosition -> String
$cshow :: EntryIconPosition -> String
showsPrec :: Int -> EntryIconPosition -> ShowS
$cshowsPrec :: Int -> EntryIconPosition -> ShowS
Show, EntryIconPosition -> EntryIconPosition -> Bool
(EntryIconPosition -> EntryIconPosition -> Bool)
-> (EntryIconPosition -> EntryIconPosition -> Bool)
-> Eq EntryIconPosition
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: EntryIconPosition -> EntryIconPosition -> Bool
$c/= :: EntryIconPosition -> EntryIconPosition -> Bool
== :: EntryIconPosition -> EntryIconPosition -> Bool
$c== :: EntryIconPosition -> EntryIconPosition -> Bool
Eq)
instance P.Enum EntryIconPosition where
fromEnum :: EntryIconPosition -> Int
fromEnum EntryIconPosition
EntryIconPositionPrimary = Int
0
fromEnum EntryIconPosition
EntryIconPositionSecondary = Int
1
fromEnum (AnotherEntryIconPosition Int
k) = Int
k
toEnum :: Int -> EntryIconPosition
toEnum Int
0 = EntryIconPosition
EntryIconPositionPrimary
toEnum Int
1 = EntryIconPosition
EntryIconPositionSecondary
toEnum Int
k = Int -> EntryIconPosition
AnotherEntryIconPosition Int
k
instance P.Ord EntryIconPosition where
compare :: EntryIconPosition -> EntryIconPosition -> Ordering
compare EntryIconPosition
a EntryIconPosition
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (EntryIconPosition -> Int
forall a. Enum a => a -> Int
P.fromEnum EntryIconPosition
a) (EntryIconPosition -> Int
forall a. Enum a => a -> Int
P.fromEnum EntryIconPosition
b)
type instance O.ParentTypes EntryIconPosition = '[]
instance O.HasParentTypes EntryIconPosition
foreign import ccall "gtk_entry_icon_position_get_type" c_gtk_entry_icon_position_get_type ::
IO GType
instance B.Types.TypedObject EntryIconPosition where
glibType :: IO GType
glibType = IO GType
c_gtk_entry_icon_position_get_type
instance B.Types.BoxedEnum EntryIconPosition
data DragResult =
DragResultSuccess
| DragResultNoTarget
| DragResultUserCancelled
| DragResultTimeoutExpired
| DragResultGrabBroken
| DragResultError
| AnotherDragResult Int
deriving (Int -> DragResult -> ShowS
[DragResult] -> ShowS
DragResult -> String
(Int -> DragResult -> ShowS)
-> (DragResult -> String)
-> ([DragResult] -> ShowS)
-> Show DragResult
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DragResult] -> ShowS
$cshowList :: [DragResult] -> ShowS
show :: DragResult -> String
$cshow :: DragResult -> String
showsPrec :: Int -> DragResult -> ShowS
$cshowsPrec :: Int -> DragResult -> ShowS
Show, DragResult -> DragResult -> Bool
(DragResult -> DragResult -> Bool)
-> (DragResult -> DragResult -> Bool) -> Eq DragResult
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DragResult -> DragResult -> Bool
$c/= :: DragResult -> DragResult -> Bool
== :: DragResult -> DragResult -> Bool
$c== :: DragResult -> DragResult -> Bool
Eq)
instance P.Enum DragResult where
fromEnum :: DragResult -> Int
fromEnum DragResult
DragResultSuccess = Int
0
fromEnum DragResult
DragResultNoTarget = Int
1
fromEnum DragResult
DragResultUserCancelled = Int
2
fromEnum DragResult
DragResultTimeoutExpired = Int
3
fromEnum DragResult
DragResultGrabBroken = Int
4
fromEnum DragResult
DragResultError = Int
5
fromEnum (AnotherDragResult Int
k) = Int
k
toEnum :: Int -> DragResult
toEnum Int
0 = DragResult
DragResultSuccess
toEnum Int
1 = DragResult
DragResultNoTarget
toEnum Int
2 = DragResult
DragResultUserCancelled
toEnum Int
3 = DragResult
DragResultTimeoutExpired
toEnum Int
4 = DragResult
DragResultGrabBroken
toEnum Int
5 = DragResult
DragResultError
toEnum Int
k = Int -> DragResult
AnotherDragResult Int
k
instance P.Ord DragResult where
compare :: DragResult -> DragResult -> Ordering
compare DragResult
a DragResult
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (DragResult -> Int
forall a. Enum a => a -> Int
P.fromEnum DragResult
a) (DragResult -> Int
forall a. Enum a => a -> Int
P.fromEnum DragResult
b)
type instance O.ParentTypes DragResult = '[]
instance O.HasParentTypes DragResult
foreign import ccall "gtk_drag_result_get_type" c_gtk_drag_result_get_type ::
IO GType
instance B.Types.TypedObject DragResult where
glibType :: IO GType
glibType = IO GType
c_gtk_drag_result_get_type
instance B.Types.BoxedEnum DragResult
data DirectionType =
DirectionTypeTabForward
| DirectionTypeTabBackward
| DirectionTypeUp
| DirectionTypeDown
| DirectionTypeLeft
| DirectionTypeRight
| AnotherDirectionType Int
deriving (Int -> DirectionType -> ShowS
[DirectionType] -> ShowS
DirectionType -> String
(Int -> DirectionType -> ShowS)
-> (DirectionType -> String)
-> ([DirectionType] -> ShowS)
-> Show DirectionType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DirectionType] -> ShowS
$cshowList :: [DirectionType] -> ShowS
show :: DirectionType -> String
$cshow :: DirectionType -> String
showsPrec :: Int -> DirectionType -> ShowS
$cshowsPrec :: Int -> DirectionType -> ShowS
Show, DirectionType -> DirectionType -> Bool
(DirectionType -> DirectionType -> Bool)
-> (DirectionType -> DirectionType -> Bool) -> Eq DirectionType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DirectionType -> DirectionType -> Bool
$c/= :: DirectionType -> DirectionType -> Bool
== :: DirectionType -> DirectionType -> Bool
$c== :: DirectionType -> DirectionType -> Bool
Eq)
instance P.Enum DirectionType where
fromEnum :: DirectionType -> Int
fromEnum DirectionType
DirectionTypeTabForward = Int
0
fromEnum DirectionType
DirectionTypeTabBackward = Int
1
fromEnum DirectionType
DirectionTypeUp = Int
2
fromEnum DirectionType
DirectionTypeDown = Int
3
fromEnum DirectionType
DirectionTypeLeft = Int
4
fromEnum DirectionType
DirectionTypeRight = Int
5
fromEnum (AnotherDirectionType Int
k) = Int
k
toEnum :: Int -> DirectionType
toEnum Int
0 = DirectionType
DirectionTypeTabForward
toEnum Int
1 = DirectionType
DirectionTypeTabBackward
toEnum Int
2 = DirectionType
DirectionTypeUp
toEnum Int
3 = DirectionType
DirectionTypeDown
toEnum Int
4 = DirectionType
DirectionTypeLeft
toEnum Int
5 = DirectionType
DirectionTypeRight
toEnum Int
k = Int -> DirectionType
AnotherDirectionType Int
k
instance P.Ord DirectionType where
compare :: DirectionType -> DirectionType -> Ordering
compare DirectionType
a DirectionType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (DirectionType -> Int
forall a. Enum a => a -> Int
P.fromEnum DirectionType
a) (DirectionType -> Int
forall a. Enum a => a -> Int
P.fromEnum DirectionType
b)
type instance O.ParentTypes DirectionType = '[]
instance O.HasParentTypes DirectionType
foreign import ccall "gtk_direction_type_get_type" c_gtk_direction_type_get_type ::
IO GType
instance B.Types.TypedObject DirectionType where
glibType :: IO GType
glibType = IO GType
c_gtk_direction_type_get_type
instance B.Types.BoxedEnum DirectionType
data DeleteType =
DeleteTypeChars
| DeleteTypeWordEnds
| DeleteTypeWords
| DeleteTypeDisplayLines
| DeleteTypeDisplayLineEnds
| DeleteTypeParagraphEnds
| DeleteTypeParagraphs
| DeleteTypeWhitespace
| AnotherDeleteType Int
deriving (Int -> DeleteType -> ShowS
[DeleteType] -> ShowS
DeleteType -> String
(Int -> DeleteType -> ShowS)
-> (DeleteType -> String)
-> ([DeleteType] -> ShowS)
-> Show DeleteType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DeleteType] -> ShowS
$cshowList :: [DeleteType] -> ShowS
show :: DeleteType -> String
$cshow :: DeleteType -> String
showsPrec :: Int -> DeleteType -> ShowS
$cshowsPrec :: Int -> DeleteType -> ShowS
Show, DeleteType -> DeleteType -> Bool
(DeleteType -> DeleteType -> Bool)
-> (DeleteType -> DeleteType -> Bool) -> Eq DeleteType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DeleteType -> DeleteType -> Bool
$c/= :: DeleteType -> DeleteType -> Bool
== :: DeleteType -> DeleteType -> Bool
$c== :: DeleteType -> DeleteType -> Bool
Eq)
instance P.Enum DeleteType where
fromEnum :: DeleteType -> Int
fromEnum DeleteType
DeleteTypeChars = Int
0
fromEnum DeleteType
DeleteTypeWordEnds = Int
1
fromEnum DeleteType
DeleteTypeWords = Int
2
fromEnum DeleteType
DeleteTypeDisplayLines = Int
3
fromEnum DeleteType
DeleteTypeDisplayLineEnds = Int
4
fromEnum DeleteType
DeleteTypeParagraphEnds = Int
5
fromEnum DeleteType
DeleteTypeParagraphs = Int
6
fromEnum DeleteType
DeleteTypeWhitespace = Int
7
fromEnum (AnotherDeleteType Int
k) = Int
k
toEnum :: Int -> DeleteType
toEnum Int
0 = DeleteType
DeleteTypeChars
toEnum Int
1 = DeleteType
DeleteTypeWordEnds
toEnum Int
2 = DeleteType
DeleteTypeWords
toEnum Int
3 = DeleteType
DeleteTypeDisplayLines
toEnum Int
4 = DeleteType
DeleteTypeDisplayLineEnds
toEnum Int
5 = DeleteType
DeleteTypeParagraphEnds
toEnum Int
6 = DeleteType
DeleteTypeParagraphs
toEnum Int
7 = DeleteType
DeleteTypeWhitespace
toEnum Int
k = Int -> DeleteType
AnotherDeleteType Int
k
instance P.Ord DeleteType where
compare :: DeleteType -> DeleteType -> Ordering
compare DeleteType
a DeleteType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (DeleteType -> Int
forall a. Enum a => a -> Int
P.fromEnum DeleteType
a) (DeleteType -> Int
forall a. Enum a => a -> Int
P.fromEnum DeleteType
b)
type instance O.ParentTypes DeleteType = '[]
instance O.HasParentTypes DeleteType
foreign import ccall "gtk_delete_type_get_type" c_gtk_delete_type_get_type ::
IO GType
instance B.Types.TypedObject DeleteType where
glibType :: IO GType
glibType = IO GType
c_gtk_delete_type_get_type
instance B.Types.BoxedEnum DeleteType
data CssSectionType =
CssSectionTypeDocument
| CssSectionTypeImport
| CssSectionTypeColorDefinition
| CssSectionTypeBindingSet
| CssSectionTypeRuleset
| CssSectionTypeSelector
| CssSectionTypeDeclaration
| CssSectionTypeValue
| CssSectionTypeKeyframes
| AnotherCssSectionType Int
deriving (Int -> CssSectionType -> ShowS
[CssSectionType] -> ShowS
CssSectionType -> String
(Int -> CssSectionType -> ShowS)
-> (CssSectionType -> String)
-> ([CssSectionType] -> ShowS)
-> Show CssSectionType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CssSectionType] -> ShowS
$cshowList :: [CssSectionType] -> ShowS
show :: CssSectionType -> String
$cshow :: CssSectionType -> String
showsPrec :: Int -> CssSectionType -> ShowS
$cshowsPrec :: Int -> CssSectionType -> ShowS
Show, CssSectionType -> CssSectionType -> Bool
(CssSectionType -> CssSectionType -> Bool)
-> (CssSectionType -> CssSectionType -> Bool) -> Eq CssSectionType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CssSectionType -> CssSectionType -> Bool
$c/= :: CssSectionType -> CssSectionType -> Bool
== :: CssSectionType -> CssSectionType -> Bool
$c== :: CssSectionType -> CssSectionType -> Bool
Eq)
instance P.Enum CssSectionType where
fromEnum :: CssSectionType -> Int
fromEnum CssSectionType
CssSectionTypeDocument = Int
0
fromEnum CssSectionType
CssSectionTypeImport = Int
1
fromEnum CssSectionType
CssSectionTypeColorDefinition = Int
2
fromEnum CssSectionType
CssSectionTypeBindingSet = Int
3
fromEnum CssSectionType
CssSectionTypeRuleset = Int
4
fromEnum CssSectionType
CssSectionTypeSelector = Int
5
fromEnum CssSectionType
CssSectionTypeDeclaration = Int
6
fromEnum CssSectionType
CssSectionTypeValue = Int
7
fromEnum CssSectionType
CssSectionTypeKeyframes = Int
8
fromEnum (AnotherCssSectionType Int
k) = Int
k
toEnum :: Int -> CssSectionType
toEnum Int
0 = CssSectionType
CssSectionTypeDocument
toEnum Int
1 = CssSectionType
CssSectionTypeImport
toEnum Int
2 = CssSectionType
CssSectionTypeColorDefinition
toEnum Int
3 = CssSectionType
CssSectionTypeBindingSet
toEnum Int
4 = CssSectionType
CssSectionTypeRuleset
toEnum Int
5 = CssSectionType
CssSectionTypeSelector
toEnum Int
6 = CssSectionType
CssSectionTypeDeclaration
toEnum Int
7 = CssSectionType
CssSectionTypeValue
toEnum Int
8 = CssSectionType
CssSectionTypeKeyframes
toEnum Int
k = Int -> CssSectionType
AnotherCssSectionType Int
k
instance P.Ord CssSectionType where
compare :: CssSectionType -> CssSectionType -> Ordering
compare CssSectionType
a CssSectionType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (CssSectionType -> Int
forall a. Enum a => a -> Int
P.fromEnum CssSectionType
a) (CssSectionType -> Int
forall a. Enum a => a -> Int
P.fromEnum CssSectionType
b)
type instance O.ParentTypes CssSectionType = '[]
instance O.HasParentTypes CssSectionType
foreign import ccall "gtk_css_section_type_get_type" c_gtk_css_section_type_get_type ::
IO GType
instance B.Types.TypedObject CssSectionType where
glibType :: IO GType
glibType = IO GType
c_gtk_css_section_type_get_type
instance B.Types.BoxedEnum CssSectionType
data CssProviderError =
CssProviderErrorFailed
| CssProviderErrorSyntax
| CssProviderErrorImport
| CssProviderErrorName
| CssProviderErrorDeprecated
| CssProviderErrorUnknownValue
| AnotherCssProviderError Int
deriving (Int -> CssProviderError -> ShowS
[CssProviderError] -> ShowS
CssProviderError -> String
(Int -> CssProviderError -> ShowS)
-> (CssProviderError -> String)
-> ([CssProviderError] -> ShowS)
-> Show CssProviderError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CssProviderError] -> ShowS
$cshowList :: [CssProviderError] -> ShowS
show :: CssProviderError -> String
$cshow :: CssProviderError -> String
showsPrec :: Int -> CssProviderError -> ShowS
$cshowsPrec :: Int -> CssProviderError -> ShowS
Show, CssProviderError -> CssProviderError -> Bool
(CssProviderError -> CssProviderError -> Bool)
-> (CssProviderError -> CssProviderError -> Bool)
-> Eq CssProviderError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CssProviderError -> CssProviderError -> Bool
$c/= :: CssProviderError -> CssProviderError -> Bool
== :: CssProviderError -> CssProviderError -> Bool
$c== :: CssProviderError -> CssProviderError -> Bool
Eq)
instance P.Enum CssProviderError where
fromEnum :: CssProviderError -> Int
fromEnum CssProviderError
CssProviderErrorFailed = Int
0
fromEnum CssProviderError
CssProviderErrorSyntax = Int
1
fromEnum CssProviderError
CssProviderErrorImport = Int
2
fromEnum CssProviderError
CssProviderErrorName = Int
3
fromEnum CssProviderError
CssProviderErrorDeprecated = Int
4
fromEnum CssProviderError
CssProviderErrorUnknownValue = Int
5
fromEnum (AnotherCssProviderError Int
k) = Int
k
toEnum :: Int -> CssProviderError
toEnum Int
0 = CssProviderError
CssProviderErrorFailed
toEnum Int
1 = CssProviderError
CssProviderErrorSyntax
toEnum Int
2 = CssProviderError
CssProviderErrorImport
toEnum Int
3 = CssProviderError
CssProviderErrorName
toEnum Int
4 = CssProviderError
CssProviderErrorDeprecated
toEnum Int
5 = CssProviderError
CssProviderErrorUnknownValue
toEnum Int
k = Int -> CssProviderError
AnotherCssProviderError Int
k
instance P.Ord CssProviderError where
compare :: CssProviderError -> CssProviderError -> Ordering
compare CssProviderError
a CssProviderError
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (CssProviderError -> Int
forall a. Enum a => a -> Int
P.fromEnum CssProviderError
a) (CssProviderError -> Int
forall a. Enum a => a -> Int
P.fromEnum CssProviderError
b)
instance GErrorClass CssProviderError where
gerrorClassDomain :: CssProviderError -> Text
gerrorClassDomain CssProviderError
_ = Text
"gtk-css-provider-error-quark"
catchCssProviderError ::
IO a ->
(CssProviderError -> GErrorMessage -> IO a) ->
IO a
catchCssProviderError :: forall a. IO a -> (CssProviderError -> Text -> IO a) -> IO a
catchCssProviderError = IO a -> (CssProviderError -> Text -> IO a) -> IO a
forall err a.
GErrorClass err =>
IO a -> (err -> Text -> IO a) -> IO a
catchGErrorJustDomain
handleCssProviderError ::
(CssProviderError -> GErrorMessage -> IO a) ->
IO a ->
IO a
handleCssProviderError :: forall a. (CssProviderError -> Text -> IO a) -> IO a -> IO a
handleCssProviderError = (CssProviderError -> Text -> IO a) -> IO a -> IO a
forall err a.
GErrorClass err =>
(err -> Text -> IO a) -> IO a -> IO a
handleGErrorJustDomain
type instance O.ParentTypes CssProviderError = '[]
instance O.HasParentTypes CssProviderError
foreign import ccall "gtk_css_provider_error_get_type" c_gtk_css_provider_error_get_type ::
IO GType
instance B.Types.TypedObject CssProviderError where
glibType :: IO GType
glibType = IO GType
c_gtk_css_provider_error_get_type
instance B.Types.BoxedEnum CssProviderError
data CornerType =
CornerTypeTopLeft
| CornerTypeBottomLeft
| CornerTypeTopRight
| CornerTypeBottomRight
| AnotherCornerType Int
deriving (Int -> CornerType -> ShowS
[CornerType] -> ShowS
CornerType -> String
(Int -> CornerType -> ShowS)
-> (CornerType -> String)
-> ([CornerType] -> ShowS)
-> Show CornerType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CornerType] -> ShowS
$cshowList :: [CornerType] -> ShowS
show :: CornerType -> String
$cshow :: CornerType -> String
showsPrec :: Int -> CornerType -> ShowS
$cshowsPrec :: Int -> CornerType -> ShowS
Show, CornerType -> CornerType -> Bool
(CornerType -> CornerType -> Bool)
-> (CornerType -> CornerType -> Bool) -> Eq CornerType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CornerType -> CornerType -> Bool
$c/= :: CornerType -> CornerType -> Bool
== :: CornerType -> CornerType -> Bool
$c== :: CornerType -> CornerType -> Bool
Eq)
instance P.Enum CornerType where
fromEnum :: CornerType -> Int
fromEnum CornerType
CornerTypeTopLeft = Int
0
fromEnum CornerType
CornerTypeBottomLeft = Int
1
fromEnum CornerType
CornerTypeTopRight = Int
2
fromEnum CornerType
CornerTypeBottomRight = Int
3
fromEnum (AnotherCornerType Int
k) = Int
k
toEnum :: Int -> CornerType
toEnum Int
0 = CornerType
CornerTypeTopLeft
toEnum Int
1 = CornerType
CornerTypeBottomLeft
toEnum Int
2 = CornerType
CornerTypeTopRight
toEnum Int
3 = CornerType
CornerTypeBottomRight
toEnum Int
k = Int -> CornerType
AnotherCornerType Int
k
instance P.Ord CornerType where
compare :: CornerType -> CornerType -> Ordering
compare CornerType
a CornerType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (CornerType -> Int
forall a. Enum a => a -> Int
P.fromEnum CornerType
a) (CornerType -> Int
forall a. Enum a => a -> Int
P.fromEnum CornerType
b)
type instance O.ParentTypes CornerType = '[]
instance O.HasParentTypes CornerType
foreign import ccall "gtk_corner_type_get_type" c_gtk_corner_type_get_type ::
IO GType
instance B.Types.TypedObject CornerType where
glibType :: IO GType
glibType = IO GType
c_gtk_corner_type_get_type
instance B.Types.BoxedEnum CornerType
data CellRendererMode =
CellRendererModeInert
| CellRendererModeActivatable
| CellRendererModeEditable
| AnotherCellRendererMode Int
deriving (Int -> CellRendererMode -> ShowS
[CellRendererMode] -> ShowS
CellRendererMode -> String
(Int -> CellRendererMode -> ShowS)
-> (CellRendererMode -> String)
-> ([CellRendererMode] -> ShowS)
-> Show CellRendererMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CellRendererMode] -> ShowS
$cshowList :: [CellRendererMode] -> ShowS
show :: CellRendererMode -> String
$cshow :: CellRendererMode -> String
showsPrec :: Int -> CellRendererMode -> ShowS
$cshowsPrec :: Int -> CellRendererMode -> ShowS
Show, CellRendererMode -> CellRendererMode -> Bool
(CellRendererMode -> CellRendererMode -> Bool)
-> (CellRendererMode -> CellRendererMode -> Bool)
-> Eq CellRendererMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CellRendererMode -> CellRendererMode -> Bool
$c/= :: CellRendererMode -> CellRendererMode -> Bool
== :: CellRendererMode -> CellRendererMode -> Bool
$c== :: CellRendererMode -> CellRendererMode -> Bool
Eq)
instance P.Enum CellRendererMode where
fromEnum :: CellRendererMode -> Int
fromEnum CellRendererMode
CellRendererModeInert = Int
0
fromEnum CellRendererMode
CellRendererModeActivatable = Int
1
fromEnum CellRendererMode
CellRendererModeEditable = Int
2
fromEnum (AnotherCellRendererMode Int
k) = Int
k
toEnum :: Int -> CellRendererMode
toEnum Int
0 = CellRendererMode
CellRendererModeInert
toEnum Int
1 = CellRendererMode
CellRendererModeActivatable
toEnum Int
2 = CellRendererMode
CellRendererModeEditable
toEnum Int
k = Int -> CellRendererMode
AnotherCellRendererMode Int
k
instance P.Ord CellRendererMode where
compare :: CellRendererMode -> CellRendererMode -> Ordering
compare CellRendererMode
a CellRendererMode
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (CellRendererMode -> Int
forall a. Enum a => a -> Int
P.fromEnum CellRendererMode
a) (CellRendererMode -> Int
forall a. Enum a => a -> Int
P.fromEnum CellRendererMode
b)
type instance O.ParentTypes CellRendererMode = '[]
instance O.HasParentTypes CellRendererMode
foreign import ccall "gtk_cell_renderer_mode_get_type" c_gtk_cell_renderer_mode_get_type ::
IO GType
instance B.Types.TypedObject CellRendererMode where
glibType :: IO GType
glibType = IO GType
c_gtk_cell_renderer_mode_get_type
instance B.Types.BoxedEnum CellRendererMode
data CellRendererAccelMode =
CellRendererAccelModeGtk
| CellRendererAccelModeOther
| AnotherCellRendererAccelMode Int
deriving (Int -> CellRendererAccelMode -> ShowS
[CellRendererAccelMode] -> ShowS
CellRendererAccelMode -> String
(Int -> CellRendererAccelMode -> ShowS)
-> (CellRendererAccelMode -> String)
-> ([CellRendererAccelMode] -> ShowS)
-> Show CellRendererAccelMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CellRendererAccelMode] -> ShowS
$cshowList :: [CellRendererAccelMode] -> ShowS
show :: CellRendererAccelMode -> String
$cshow :: CellRendererAccelMode -> String
showsPrec :: Int -> CellRendererAccelMode -> ShowS
$cshowsPrec :: Int -> CellRendererAccelMode -> ShowS
Show, CellRendererAccelMode -> CellRendererAccelMode -> Bool
(CellRendererAccelMode -> CellRendererAccelMode -> Bool)
-> (CellRendererAccelMode -> CellRendererAccelMode -> Bool)
-> Eq CellRendererAccelMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CellRendererAccelMode -> CellRendererAccelMode -> Bool
$c/= :: CellRendererAccelMode -> CellRendererAccelMode -> Bool
== :: CellRendererAccelMode -> CellRendererAccelMode -> Bool
$c== :: CellRendererAccelMode -> CellRendererAccelMode -> Bool
Eq)
instance P.Enum CellRendererAccelMode where
fromEnum :: CellRendererAccelMode -> Int
fromEnum CellRendererAccelMode
CellRendererAccelModeGtk = Int
0
fromEnum CellRendererAccelMode
CellRendererAccelModeOther = Int
1
fromEnum (AnotherCellRendererAccelMode Int
k) = Int
k
toEnum :: Int -> CellRendererAccelMode
toEnum Int
0 = CellRendererAccelMode
CellRendererAccelModeGtk
toEnum Int
1 = CellRendererAccelMode
CellRendererAccelModeOther
toEnum Int
k = Int -> CellRendererAccelMode
AnotherCellRendererAccelMode Int
k
instance P.Ord CellRendererAccelMode where
compare :: CellRendererAccelMode -> CellRendererAccelMode -> Ordering
compare CellRendererAccelMode
a CellRendererAccelMode
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (CellRendererAccelMode -> Int
forall a. Enum a => a -> Int
P.fromEnum CellRendererAccelMode
a) (CellRendererAccelMode -> Int
forall a. Enum a => a -> Int
P.fromEnum CellRendererAccelMode
b)
type instance O.ParentTypes CellRendererAccelMode = '[]
instance O.HasParentTypes CellRendererAccelMode
foreign import ccall "gtk_cell_renderer_accel_mode_get_type" c_gtk_cell_renderer_accel_mode_get_type ::
IO GType
instance B.Types.TypedObject CellRendererAccelMode where
glibType :: IO GType
glibType = IO GType
c_gtk_cell_renderer_accel_mode_get_type
instance B.Types.BoxedEnum CellRendererAccelMode
data ButtonsType =
ButtonsTypeNone
| ButtonsTypeOk
| ButtonsTypeClose
| ButtonsTypeCancel
| ButtonsTypeYesNo
| ButtonsTypeOkCancel
| AnotherButtonsType Int
deriving (Int -> ButtonsType -> ShowS
[ButtonsType] -> ShowS
ButtonsType -> String
(Int -> ButtonsType -> ShowS)
-> (ButtonsType -> String)
-> ([ButtonsType] -> ShowS)
-> Show ButtonsType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ButtonsType] -> ShowS
$cshowList :: [ButtonsType] -> ShowS
show :: ButtonsType -> String
$cshow :: ButtonsType -> String
showsPrec :: Int -> ButtonsType -> ShowS
$cshowsPrec :: Int -> ButtonsType -> ShowS
Show, ButtonsType -> ButtonsType -> Bool
(ButtonsType -> ButtonsType -> Bool)
-> (ButtonsType -> ButtonsType -> Bool) -> Eq ButtonsType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ButtonsType -> ButtonsType -> Bool
$c/= :: ButtonsType -> ButtonsType -> Bool
== :: ButtonsType -> ButtonsType -> Bool
$c== :: ButtonsType -> ButtonsType -> Bool
Eq)
instance P.Enum ButtonsType where
fromEnum :: ButtonsType -> Int
fromEnum ButtonsType
ButtonsTypeNone = Int
0
fromEnum ButtonsType
ButtonsTypeOk = Int
1
fromEnum ButtonsType
ButtonsTypeClose = Int
2
fromEnum ButtonsType
ButtonsTypeCancel = Int
3
fromEnum ButtonsType
ButtonsTypeYesNo = Int
4
fromEnum ButtonsType
ButtonsTypeOkCancel = Int
5
fromEnum (AnotherButtonsType Int
k) = Int
k
toEnum :: Int -> ButtonsType
toEnum Int
0 = ButtonsType
ButtonsTypeNone
toEnum Int
1 = ButtonsType
ButtonsTypeOk
toEnum Int
2 = ButtonsType
ButtonsTypeClose
toEnum Int
3 = ButtonsType
ButtonsTypeCancel
toEnum Int
4 = ButtonsType
ButtonsTypeYesNo
toEnum Int
5 = ButtonsType
ButtonsTypeOkCancel
toEnum Int
k = Int -> ButtonsType
AnotherButtonsType Int
k
instance P.Ord ButtonsType where
compare :: ButtonsType -> ButtonsType -> Ordering
compare ButtonsType
a ButtonsType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ButtonsType -> Int
forall a. Enum a => a -> Int
P.fromEnum ButtonsType
a) (ButtonsType -> Int
forall a. Enum a => a -> Int
P.fromEnum ButtonsType
b)
type instance O.ParentTypes ButtonsType = '[]
instance O.HasParentTypes ButtonsType
foreign import ccall "gtk_buttons_type_get_type" c_gtk_buttons_type_get_type ::
IO GType
instance B.Types.TypedObject ButtonsType where
glibType :: IO GType
glibType = IO GType
c_gtk_buttons_type_get_type
instance B.Types.BoxedEnum ButtonsType
data ButtonRole =
ButtonRoleNormal
| ButtonRoleCheck
| ButtonRoleRadio
| AnotherButtonRole Int
deriving (Int -> ButtonRole -> ShowS
[ButtonRole] -> ShowS
ButtonRole -> String
(Int -> ButtonRole -> ShowS)
-> (ButtonRole -> String)
-> ([ButtonRole] -> ShowS)
-> Show ButtonRole
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ButtonRole] -> ShowS
$cshowList :: [ButtonRole] -> ShowS
show :: ButtonRole -> String
$cshow :: ButtonRole -> String
showsPrec :: Int -> ButtonRole -> ShowS
$cshowsPrec :: Int -> ButtonRole -> ShowS
Show, ButtonRole -> ButtonRole -> Bool
(ButtonRole -> ButtonRole -> Bool)
-> (ButtonRole -> ButtonRole -> Bool) -> Eq ButtonRole
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ButtonRole -> ButtonRole -> Bool
$c/= :: ButtonRole -> ButtonRole -> Bool
== :: ButtonRole -> ButtonRole -> Bool
$c== :: ButtonRole -> ButtonRole -> Bool
Eq)
instance P.Enum ButtonRole where
fromEnum :: ButtonRole -> Int
fromEnum ButtonRole
ButtonRoleNormal = Int
0
fromEnum ButtonRole
ButtonRoleCheck = Int
1
fromEnum ButtonRole
ButtonRoleRadio = Int
2
fromEnum (AnotherButtonRole Int
k) = Int
k
toEnum :: Int -> ButtonRole
toEnum Int
0 = ButtonRole
ButtonRoleNormal
toEnum Int
1 = ButtonRole
ButtonRoleCheck
toEnum Int
2 = ButtonRole
ButtonRoleRadio
toEnum Int
k = Int -> ButtonRole
AnotherButtonRole Int
k
instance P.Ord ButtonRole where
compare :: ButtonRole -> ButtonRole -> Ordering
compare ButtonRole
a ButtonRole
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ButtonRole -> Int
forall a. Enum a => a -> Int
P.fromEnum ButtonRole
a) (ButtonRole -> Int
forall a. Enum a => a -> Int
P.fromEnum ButtonRole
b)
type instance O.ParentTypes ButtonRole = '[]
instance O.HasParentTypes ButtonRole
foreign import ccall "gtk_button_role_get_type" c_gtk_button_role_get_type ::
IO GType
instance B.Types.TypedObject ButtonRole where
glibType :: IO GType
glibType = IO GType
c_gtk_button_role_get_type
instance B.Types.BoxedEnum ButtonRole
data ButtonBoxStyle =
ButtonBoxStyleSpread
| ButtonBoxStyleEdge
| ButtonBoxStyleStart
| ButtonBoxStyleEnd
| ButtonBoxStyleCenter
| ButtonBoxStyleExpand
| AnotherButtonBoxStyle Int
deriving (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
showList :: [ButtonBoxStyle] -> ShowS
$cshowList :: [ButtonBoxStyle] -> ShowS
show :: ButtonBoxStyle -> String
$cshow :: ButtonBoxStyle -> String
showsPrec :: Int -> ButtonBoxStyle -> ShowS
$cshowsPrec :: Int -> ButtonBoxStyle -> ShowS
Show, ButtonBoxStyle -> ButtonBoxStyle -> Bool
(ButtonBoxStyle -> ButtonBoxStyle -> Bool)
-> (ButtonBoxStyle -> ButtonBoxStyle -> Bool) -> Eq ButtonBoxStyle
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ButtonBoxStyle -> ButtonBoxStyle -> Bool
$c/= :: ButtonBoxStyle -> ButtonBoxStyle -> Bool
== :: ButtonBoxStyle -> ButtonBoxStyle -> Bool
$c== :: ButtonBoxStyle -> ButtonBoxStyle -> Bool
Eq)
instance P.Enum ButtonBoxStyle where
fromEnum :: ButtonBoxStyle -> Int
fromEnum ButtonBoxStyle
ButtonBoxStyleSpread = Int
1
fromEnum ButtonBoxStyle
ButtonBoxStyleEdge = Int
2
fromEnum ButtonBoxStyle
ButtonBoxStyleStart = Int
3
fromEnum ButtonBoxStyle
ButtonBoxStyleEnd = Int
4
fromEnum ButtonBoxStyle
ButtonBoxStyleCenter = Int
5
fromEnum ButtonBoxStyle
ButtonBoxStyleExpand = Int
6
fromEnum (AnotherButtonBoxStyle Int
k) = Int
k
toEnum :: Int -> ButtonBoxStyle
toEnum Int
1 = ButtonBoxStyle
ButtonBoxStyleSpread
toEnum Int
2 = ButtonBoxStyle
ButtonBoxStyleEdge
toEnum Int
3 = ButtonBoxStyle
ButtonBoxStyleStart
toEnum Int
4 = ButtonBoxStyle
ButtonBoxStyleEnd
toEnum Int
5 = ButtonBoxStyle
ButtonBoxStyleCenter
toEnum Int
6 = ButtonBoxStyle
ButtonBoxStyleExpand
toEnum Int
k = Int -> ButtonBoxStyle
AnotherButtonBoxStyle Int
k
instance P.Ord ButtonBoxStyle where
compare :: ButtonBoxStyle -> ButtonBoxStyle -> Ordering
compare ButtonBoxStyle
a ButtonBoxStyle
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ButtonBoxStyle -> Int
forall a. Enum a => a -> Int
P.fromEnum ButtonBoxStyle
a) (ButtonBoxStyle -> Int
forall a. Enum a => a -> Int
P.fromEnum ButtonBoxStyle
b)
type instance O.ParentTypes ButtonBoxStyle = '[]
instance O.HasParentTypes ButtonBoxStyle
foreign import ccall "gtk_button_box_style_get_type" c_gtk_button_box_style_get_type ::
IO GType
instance B.Types.TypedObject ButtonBoxStyle where
glibType :: IO GType
glibType = IO GType
c_gtk_button_box_style_get_type
instance B.Types.BoxedEnum ButtonBoxStyle
data BuilderError =
BuilderErrorInvalidTypeFunction
| BuilderErrorUnhandledTag
| BuilderErrorMissingAttribute
| BuilderErrorInvalidAttribute
| BuilderErrorInvalidTag
| BuilderErrorMissingPropertyValue
| BuilderErrorInvalidValue
| BuilderErrorVersionMismatch
| BuilderErrorDuplicateId
| BuilderErrorObjectTypeRefused
| BuilderErrorTemplateMismatch
| BuilderErrorInvalidProperty
| BuilderErrorInvalidSignal
| BuilderErrorInvalidId
| AnotherBuilderError Int
deriving (Int -> BuilderError -> ShowS
[BuilderError] -> ShowS
BuilderError -> String
(Int -> BuilderError -> ShowS)
-> (BuilderError -> String)
-> ([BuilderError] -> ShowS)
-> Show BuilderError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BuilderError] -> ShowS
$cshowList :: [BuilderError] -> ShowS
show :: BuilderError -> String
$cshow :: BuilderError -> String
showsPrec :: Int -> BuilderError -> ShowS
$cshowsPrec :: Int -> BuilderError -> ShowS
Show, BuilderError -> BuilderError -> Bool
(BuilderError -> BuilderError -> Bool)
-> (BuilderError -> BuilderError -> Bool) -> Eq BuilderError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BuilderError -> BuilderError -> Bool
$c/= :: BuilderError -> BuilderError -> Bool
== :: BuilderError -> BuilderError -> Bool
$c== :: BuilderError -> BuilderError -> Bool
Eq)
instance P.Enum BuilderError where
fromEnum :: BuilderError -> Int
fromEnum BuilderError
BuilderErrorInvalidTypeFunction = Int
0
fromEnum BuilderError
BuilderErrorUnhandledTag = Int
1
fromEnum BuilderError
BuilderErrorMissingAttribute = Int
2
fromEnum BuilderError
BuilderErrorInvalidAttribute = Int
3
fromEnum BuilderError
BuilderErrorInvalidTag = Int
4
fromEnum BuilderError
BuilderErrorMissingPropertyValue = Int
5
fromEnum BuilderError
BuilderErrorInvalidValue = Int
6
fromEnum BuilderError
BuilderErrorVersionMismatch = Int
7
fromEnum BuilderError
BuilderErrorDuplicateId = Int
8
fromEnum BuilderError
BuilderErrorObjectTypeRefused = Int
9
fromEnum BuilderError
BuilderErrorTemplateMismatch = Int
10
fromEnum BuilderError
BuilderErrorInvalidProperty = Int
11
fromEnum BuilderError
BuilderErrorInvalidSignal = Int
12
fromEnum BuilderError
BuilderErrorInvalidId = Int
13
fromEnum (AnotherBuilderError Int
k) = Int
k
toEnum :: Int -> BuilderError
toEnum Int
0 = BuilderError
BuilderErrorInvalidTypeFunction
toEnum Int
1 = BuilderError
BuilderErrorUnhandledTag
toEnum Int
2 = BuilderError
BuilderErrorMissingAttribute
toEnum Int
3 = BuilderError
BuilderErrorInvalidAttribute
toEnum Int
4 = BuilderError
BuilderErrorInvalidTag
toEnum Int
5 = BuilderError
BuilderErrorMissingPropertyValue
toEnum Int
6 = BuilderError
BuilderErrorInvalidValue
toEnum Int
7 = BuilderError
BuilderErrorVersionMismatch
toEnum Int
8 = BuilderError
BuilderErrorDuplicateId
toEnum Int
9 = BuilderError
BuilderErrorObjectTypeRefused
toEnum Int
10 = BuilderError
BuilderErrorTemplateMismatch
toEnum Int
11 = BuilderError
BuilderErrorInvalidProperty
toEnum Int
12 = BuilderError
BuilderErrorInvalidSignal
toEnum Int
13 = BuilderError
BuilderErrorInvalidId
toEnum Int
k = Int -> BuilderError
AnotherBuilderError Int
k
instance P.Ord BuilderError where
compare :: BuilderError -> BuilderError -> Ordering
compare BuilderError
a BuilderError
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (BuilderError -> Int
forall a. Enum a => a -> Int
P.fromEnum BuilderError
a) (BuilderError -> Int
forall a. Enum a => a -> Int
P.fromEnum BuilderError
b)
instance GErrorClass BuilderError where
gerrorClassDomain :: BuilderError -> Text
gerrorClassDomain BuilderError
_ = Text
"gtk-builder-error-quark"
catchBuilderError ::
IO a ->
(BuilderError -> GErrorMessage -> IO a) ->
IO a
catchBuilderError :: forall a. IO a -> (BuilderError -> Text -> IO a) -> IO a
catchBuilderError = IO a -> (BuilderError -> Text -> IO a) -> IO a
forall err a.
GErrorClass err =>
IO a -> (err -> Text -> IO a) -> IO a
catchGErrorJustDomain
handleBuilderError ::
(BuilderError -> GErrorMessage -> IO a) ->
IO a ->
IO a
handleBuilderError :: forall a. (BuilderError -> Text -> IO a) -> IO a -> IO a
handleBuilderError = (BuilderError -> Text -> IO a) -> IO a -> IO a
forall err a.
GErrorClass err =>
(err -> Text -> IO a) -> IO a -> IO a
handleGErrorJustDomain
type instance O.ParentTypes BuilderError = '[]
instance O.HasParentTypes BuilderError
foreign import ccall "gtk_builder_error_get_type" c_gtk_builder_error_get_type ::
IO GType
instance B.Types.TypedObject BuilderError where
glibType :: IO GType
glibType = IO GType
c_gtk_builder_error_get_type
instance B.Types.BoxedEnum BuilderError
data BorderStyle =
BorderStyleNone
| BorderStyleSolid
| BorderStyleInset
| BorderStyleOutset
| BorderStyleHidden
| BorderStyleDotted
| BorderStyleDashed
| BorderStyleDouble
| BorderStyleGroove
| BorderStyleRidge
| AnotherBorderStyle Int
deriving (Int -> BorderStyle -> ShowS
[BorderStyle] -> ShowS
BorderStyle -> String
(Int -> BorderStyle -> ShowS)
-> (BorderStyle -> String)
-> ([BorderStyle] -> ShowS)
-> Show BorderStyle
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BorderStyle] -> ShowS
$cshowList :: [BorderStyle] -> ShowS
show :: BorderStyle -> String
$cshow :: BorderStyle -> String
showsPrec :: Int -> BorderStyle -> ShowS
$cshowsPrec :: Int -> BorderStyle -> ShowS
Show, BorderStyle -> BorderStyle -> Bool
(BorderStyle -> BorderStyle -> Bool)
-> (BorderStyle -> BorderStyle -> Bool) -> Eq BorderStyle
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BorderStyle -> BorderStyle -> Bool
$c/= :: BorderStyle -> BorderStyle -> Bool
== :: BorderStyle -> BorderStyle -> Bool
$c== :: BorderStyle -> BorderStyle -> Bool
Eq)
instance P.Enum BorderStyle where
fromEnum :: BorderStyle -> Int
fromEnum BorderStyle
BorderStyleNone = Int
0
fromEnum BorderStyle
BorderStyleSolid = Int
1
fromEnum BorderStyle
BorderStyleInset = Int
2
fromEnum BorderStyle
BorderStyleOutset = Int
3
fromEnum BorderStyle
BorderStyleHidden = Int
4
fromEnum BorderStyle
BorderStyleDotted = Int
5
fromEnum BorderStyle
BorderStyleDashed = Int
6
fromEnum BorderStyle
BorderStyleDouble = Int
7
fromEnum BorderStyle
BorderStyleGroove = Int
8
fromEnum BorderStyle
BorderStyleRidge = Int
9
fromEnum (AnotherBorderStyle Int
k) = Int
k
toEnum :: Int -> BorderStyle
toEnum Int
0 = BorderStyle
BorderStyleNone
toEnum Int
1 = BorderStyle
BorderStyleSolid
toEnum Int
2 = BorderStyle
BorderStyleInset
toEnum Int
3 = BorderStyle
BorderStyleOutset
toEnum Int
4 = BorderStyle
BorderStyleHidden
toEnum Int
5 = BorderStyle
BorderStyleDotted
toEnum Int
6 = BorderStyle
BorderStyleDashed
toEnum Int
7 = BorderStyle
BorderStyleDouble
toEnum Int
8 = BorderStyle
BorderStyleGroove
toEnum Int
9 = BorderStyle
BorderStyleRidge
toEnum Int
k = Int -> BorderStyle
AnotherBorderStyle Int
k
instance P.Ord BorderStyle where
compare :: BorderStyle -> BorderStyle -> Ordering
compare BorderStyle
a BorderStyle
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (BorderStyle -> Int
forall a. Enum a => a -> Int
P.fromEnum BorderStyle
a) (BorderStyle -> Int
forall a. Enum a => a -> Int
P.fromEnum BorderStyle
b)
type instance O.ParentTypes BorderStyle = '[]
instance O.HasParentTypes BorderStyle
foreign import ccall "gtk_border_style_get_type" c_gtk_border_style_get_type ::
IO GType
instance B.Types.TypedObject BorderStyle where
glibType :: IO GType
glibType = IO GType
c_gtk_border_style_get_type
instance B.Types.BoxedEnum BorderStyle
data BaselinePosition =
BaselinePositionTop
| BaselinePositionCenter
| BaselinePositionBottom
| AnotherBaselinePosition Int
deriving (Int -> BaselinePosition -> ShowS
[BaselinePosition] -> ShowS
BaselinePosition -> String
(Int -> BaselinePosition -> ShowS)
-> (BaselinePosition -> String)
-> ([BaselinePosition] -> ShowS)
-> Show BaselinePosition
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BaselinePosition] -> ShowS
$cshowList :: [BaselinePosition] -> ShowS
show :: BaselinePosition -> String
$cshow :: BaselinePosition -> String
showsPrec :: Int -> BaselinePosition -> ShowS
$cshowsPrec :: Int -> BaselinePosition -> ShowS
Show, BaselinePosition -> BaselinePosition -> Bool
(BaselinePosition -> BaselinePosition -> Bool)
-> (BaselinePosition -> BaselinePosition -> Bool)
-> Eq BaselinePosition
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BaselinePosition -> BaselinePosition -> Bool
$c/= :: BaselinePosition -> BaselinePosition -> Bool
== :: BaselinePosition -> BaselinePosition -> Bool
$c== :: BaselinePosition -> BaselinePosition -> Bool
Eq)
instance P.Enum BaselinePosition where
fromEnum :: BaselinePosition -> Int
fromEnum BaselinePosition
BaselinePositionTop = Int
0
fromEnum BaselinePosition
BaselinePositionCenter = Int
1
fromEnum BaselinePosition
BaselinePositionBottom = Int
2
fromEnum (AnotherBaselinePosition Int
k) = Int
k
toEnum :: Int -> BaselinePosition
toEnum Int
0 = BaselinePosition
BaselinePositionTop
toEnum Int
1 = BaselinePosition
BaselinePositionCenter
toEnum Int
2 = BaselinePosition
BaselinePositionBottom
toEnum Int
k = Int -> BaselinePosition
AnotherBaselinePosition Int
k
instance P.Ord BaselinePosition where
compare :: BaselinePosition -> BaselinePosition -> Ordering
compare BaselinePosition
a BaselinePosition
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (BaselinePosition -> Int
forall a. Enum a => a -> Int
P.fromEnum BaselinePosition
a) (BaselinePosition -> Int
forall a. Enum a => a -> Int
P.fromEnum BaselinePosition
b)
type instance O.ParentTypes BaselinePosition = '[]
instance O.HasParentTypes BaselinePosition
foreign import ccall "gtk_baseline_position_get_type" c_gtk_baseline_position_get_type ::
IO GType
instance B.Types.TypedObject BaselinePosition where
glibType :: IO GType
glibType = IO GType
c_gtk_baseline_position_get_type
instance B.Types.BoxedEnum BaselinePosition
data AssistantPageType =
AssistantPageTypeContent
| AssistantPageTypeIntro
| AssistantPageTypeConfirm
| AssistantPageTypeSummary
| AssistantPageTypeProgress
| AssistantPageTypeCustom
| AnotherAssistantPageType Int
deriving (Int -> AssistantPageType -> ShowS
[AssistantPageType] -> ShowS
AssistantPageType -> String
(Int -> AssistantPageType -> ShowS)
-> (AssistantPageType -> String)
-> ([AssistantPageType] -> ShowS)
-> Show AssistantPageType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AssistantPageType] -> ShowS
$cshowList :: [AssistantPageType] -> ShowS
show :: AssistantPageType -> String
$cshow :: AssistantPageType -> String
showsPrec :: Int -> AssistantPageType -> ShowS
$cshowsPrec :: Int -> AssistantPageType -> ShowS
Show, AssistantPageType -> AssistantPageType -> Bool
(AssistantPageType -> AssistantPageType -> Bool)
-> (AssistantPageType -> AssistantPageType -> Bool)
-> Eq AssistantPageType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AssistantPageType -> AssistantPageType -> Bool
$c/= :: AssistantPageType -> AssistantPageType -> Bool
== :: AssistantPageType -> AssistantPageType -> Bool
$c== :: AssistantPageType -> AssistantPageType -> Bool
Eq)
instance P.Enum AssistantPageType where
fromEnum :: AssistantPageType -> Int
fromEnum AssistantPageType
AssistantPageTypeContent = Int
0
fromEnum AssistantPageType
AssistantPageTypeIntro = Int
1
fromEnum AssistantPageType
AssistantPageTypeConfirm = Int
2
fromEnum AssistantPageType
AssistantPageTypeSummary = Int
3
fromEnum AssistantPageType
AssistantPageTypeProgress = Int
4
fromEnum AssistantPageType
AssistantPageTypeCustom = Int
5
fromEnum (AnotherAssistantPageType Int
k) = Int
k
toEnum :: Int -> AssistantPageType
toEnum Int
0 = AssistantPageType
AssistantPageTypeContent
toEnum Int
1 = AssistantPageType
AssistantPageTypeIntro
toEnum Int
2 = AssistantPageType
AssistantPageTypeConfirm
toEnum Int
3 = AssistantPageType
AssistantPageTypeSummary
toEnum Int
4 = AssistantPageType
AssistantPageTypeProgress
toEnum Int
5 = AssistantPageType
AssistantPageTypeCustom
toEnum Int
k = Int -> AssistantPageType
AnotherAssistantPageType Int
k
instance P.Ord AssistantPageType where
compare :: AssistantPageType -> AssistantPageType -> Ordering
compare AssistantPageType
a AssistantPageType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (AssistantPageType -> Int
forall a. Enum a => a -> Int
P.fromEnum AssistantPageType
a) (AssistantPageType -> Int
forall a. Enum a => a -> Int
P.fromEnum AssistantPageType
b)
type instance O.ParentTypes AssistantPageType = '[]
instance O.HasParentTypes AssistantPageType
foreign import ccall "gtk_assistant_page_type_get_type" c_gtk_assistant_page_type_get_type ::
IO GType
instance B.Types.TypedObject AssistantPageType where
glibType :: IO GType
glibType = IO GType
c_gtk_assistant_page_type_get_type
instance B.Types.BoxedEnum AssistantPageType
data ArrowType =
ArrowTypeUp
| ArrowTypeDown
| ArrowTypeLeft
| ArrowTypeRight
| ArrowTypeNone
| AnotherArrowType Int
deriving (Int -> ArrowType -> ShowS
[ArrowType] -> ShowS
ArrowType -> String
(Int -> ArrowType -> ShowS)
-> (ArrowType -> String)
-> ([ArrowType] -> ShowS)
-> Show ArrowType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ArrowType] -> ShowS
$cshowList :: [ArrowType] -> ShowS
show :: ArrowType -> String
$cshow :: ArrowType -> String
showsPrec :: Int -> ArrowType -> ShowS
$cshowsPrec :: Int -> ArrowType -> ShowS
Show, ArrowType -> ArrowType -> Bool
(ArrowType -> ArrowType -> Bool)
-> (ArrowType -> ArrowType -> Bool) -> Eq ArrowType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ArrowType -> ArrowType -> Bool
$c/= :: ArrowType -> ArrowType -> Bool
== :: ArrowType -> ArrowType -> Bool
$c== :: ArrowType -> ArrowType -> Bool
Eq)
instance P.Enum ArrowType where
fromEnum :: ArrowType -> Int
fromEnum ArrowType
ArrowTypeUp = Int
0
fromEnum ArrowType
ArrowTypeDown = Int
1
fromEnum ArrowType
ArrowTypeLeft = Int
2
fromEnum ArrowType
ArrowTypeRight = Int
3
fromEnum ArrowType
ArrowTypeNone = Int
4
fromEnum (AnotherArrowType Int
k) = Int
k
toEnum :: Int -> ArrowType
toEnum Int
0 = ArrowType
ArrowTypeUp
toEnum Int
1 = ArrowType
ArrowTypeDown
toEnum Int
2 = ArrowType
ArrowTypeLeft
toEnum Int
3 = ArrowType
ArrowTypeRight
toEnum Int
4 = ArrowType
ArrowTypeNone
toEnum Int
k = Int -> ArrowType
AnotherArrowType Int
k
instance P.Ord ArrowType where
compare :: ArrowType -> ArrowType -> Ordering
compare ArrowType
a ArrowType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ArrowType -> Int
forall a. Enum a => a -> Int
P.fromEnum ArrowType
a) (ArrowType -> Int
forall a. Enum a => a -> Int
P.fromEnum ArrowType
b)
type instance O.ParentTypes ArrowType = '[]
instance O.HasParentTypes ArrowType
foreign import ccall "gtk_arrow_type_get_type" c_gtk_arrow_type_get_type ::
IO GType
instance B.Types.TypedObject ArrowType where
glibType :: IO GType
glibType = IO GType
c_gtk_arrow_type_get_type
instance B.Types.BoxedEnum ArrowType
data ArrowPlacement =
ArrowPlacementBoth
| ArrowPlacementStart
| ArrowPlacementEnd
| AnotherArrowPlacement Int
deriving (Int -> ArrowPlacement -> ShowS
[ArrowPlacement] -> ShowS
ArrowPlacement -> String
(Int -> ArrowPlacement -> ShowS)
-> (ArrowPlacement -> String)
-> ([ArrowPlacement] -> ShowS)
-> Show ArrowPlacement
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ArrowPlacement] -> ShowS
$cshowList :: [ArrowPlacement] -> ShowS
show :: ArrowPlacement -> String
$cshow :: ArrowPlacement -> String
showsPrec :: Int -> ArrowPlacement -> ShowS
$cshowsPrec :: Int -> ArrowPlacement -> ShowS
Show, ArrowPlacement -> ArrowPlacement -> Bool
(ArrowPlacement -> ArrowPlacement -> Bool)
-> (ArrowPlacement -> ArrowPlacement -> Bool) -> Eq ArrowPlacement
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ArrowPlacement -> ArrowPlacement -> Bool
$c/= :: ArrowPlacement -> ArrowPlacement -> Bool
== :: ArrowPlacement -> ArrowPlacement -> Bool
$c== :: ArrowPlacement -> ArrowPlacement -> Bool
Eq)
instance P.Enum ArrowPlacement where
fromEnum :: ArrowPlacement -> Int
fromEnum ArrowPlacement
ArrowPlacementBoth = Int
0
fromEnum ArrowPlacement
ArrowPlacementStart = Int
1
fromEnum ArrowPlacement
ArrowPlacementEnd = Int
2
fromEnum (AnotherArrowPlacement Int
k) = Int
k
toEnum :: Int -> ArrowPlacement
toEnum Int
0 = ArrowPlacement
ArrowPlacementBoth
toEnum Int
1 = ArrowPlacement
ArrowPlacementStart
toEnum Int
2 = ArrowPlacement
ArrowPlacementEnd
toEnum Int
k = Int -> ArrowPlacement
AnotherArrowPlacement Int
k
instance P.Ord ArrowPlacement where
compare :: ArrowPlacement -> ArrowPlacement -> Ordering
compare ArrowPlacement
a ArrowPlacement
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ArrowPlacement -> Int
forall a. Enum a => a -> Int
P.fromEnum ArrowPlacement
a) (ArrowPlacement -> Int
forall a. Enum a => a -> Int
P.fromEnum ArrowPlacement
b)
type instance O.ParentTypes ArrowPlacement = '[]
instance O.HasParentTypes ArrowPlacement
foreign import ccall "gtk_arrow_placement_get_type" c_gtk_arrow_placement_get_type ::
IO GType
instance B.Types.TypedObject ArrowPlacement where
glibType :: IO GType
glibType = IO GType
c_gtk_arrow_placement_get_type
instance B.Types.BoxedEnum ArrowPlacement
data Align =
AlignFill
| AlignStart
| AlignEnd
| AlignCenter
| AlignBaseline
| AnotherAlign Int
deriving (Int -> Align -> ShowS
[Align] -> ShowS
Align -> String
(Int -> Align -> ShowS)
-> (Align -> String) -> ([Align] -> ShowS) -> Show Align
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Align] -> ShowS
$cshowList :: [Align] -> ShowS
show :: Align -> String
$cshow :: Align -> String
showsPrec :: Int -> Align -> ShowS
$cshowsPrec :: Int -> Align -> ShowS
Show, Align -> Align -> Bool
(Align -> Align -> Bool) -> (Align -> Align -> Bool) -> Eq Align
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Align -> Align -> Bool
$c/= :: Align -> Align -> Bool
== :: Align -> Align -> Bool
$c== :: Align -> Align -> Bool
Eq)
instance P.Enum Align where
fromEnum :: Align -> Int
fromEnum Align
AlignFill = Int
0
fromEnum Align
AlignStart = Int
1
fromEnum Align
AlignEnd = Int
2
fromEnum Align
AlignCenter = Int
3
fromEnum Align
AlignBaseline = Int
4
fromEnum (AnotherAlign Int
k) = Int
k
toEnum :: Int -> Align
toEnum Int
0 = Align
AlignFill
toEnum Int
1 = Align
AlignStart
toEnum Int
2 = Align
AlignEnd
toEnum Int
3 = Align
AlignCenter
toEnum Int
4 = Align
AlignBaseline
toEnum Int
k = Int -> Align
AnotherAlign Int
k
instance P.Ord Align where
compare :: Align -> Align -> Ordering
compare Align
a Align
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (Align -> Int
forall a. Enum a => a -> Int
P.fromEnum Align
a) (Align -> Int
forall a. Enum a => a -> Int
P.fromEnum Align
b)
type instance O.ParentTypes Align = '[]
instance O.HasParentTypes Align
foreign import ccall "gtk_align_get_type" c_gtk_align_get_type ::
IO GType
instance B.Types.TypedObject Align where
glibType :: IO GType
glibType = IO GType
c_gtk_align_get_type
instance B.Types.BoxedEnum Align