#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.ManagedPtr as B.ManagedPtr
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 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
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 WrapModeNone = 0
fromEnum WrapModeChar = 1
fromEnum WrapModeWord = 2
fromEnum WrapModeWordChar = 3
fromEnum (AnotherWrapMode k :: Int
k) = Int
k
toEnum :: Int -> WrapMode
toEnum 0 = WrapMode
WrapModeNone
toEnum 1 = WrapMode
WrapModeChar
toEnum 2 = WrapMode
WrapModeWord
toEnum 3 = WrapMode
WrapModeWordChar
toEnum k :: Int
k = Int -> WrapMode
AnotherWrapMode Int
k
instance P.Ord WrapMode where
compare :: WrapMode -> WrapMode -> Ordering
compare a :: WrapMode
a b :: 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)
foreign import ccall "gtk_wrap_mode_get_type" c_gtk_wrap_mode_get_type ::
IO GType
instance BoxedEnum WrapMode where
boxedEnumType :: WrapMode -> IO GType
boxedEnumType _ = IO GType
c_gtk_wrap_mode_get_type
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 WindowTypeToplevel = 0
fromEnum WindowTypePopup = 1
fromEnum (AnotherWindowType k :: Int
k) = Int
k
toEnum :: Int -> WindowType
toEnum 0 = WindowType
WindowTypeToplevel
toEnum 1 = WindowType
WindowTypePopup
toEnum k :: Int
k = Int -> WindowType
AnotherWindowType Int
k
instance P.Ord WindowType where
compare :: WindowType -> WindowType -> Ordering
compare a :: WindowType
a b :: 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)
foreign import ccall "gtk_window_type_get_type" c_gtk_window_type_get_type ::
IO GType
instance BoxedEnum WindowType where
boxedEnumType :: WindowType -> IO GType
boxedEnumType _ = IO GType
c_gtk_window_type_get_type
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 WindowPositionNone = 0
fromEnum WindowPositionCenter = 1
fromEnum WindowPositionMouse = 2
fromEnum WindowPositionCenterAlways = 3
fromEnum WindowPositionCenterOnParent = 4
fromEnum (AnotherWindowPosition k :: Int
k) = Int
k
toEnum :: Int -> WindowPosition
toEnum 0 = WindowPosition
WindowPositionNone
toEnum 1 = WindowPosition
WindowPositionCenter
toEnum 2 = WindowPosition
WindowPositionMouse
toEnum 3 = WindowPosition
WindowPositionCenterAlways
toEnum 4 = WindowPosition
WindowPositionCenterOnParent
toEnum k :: Int
k = Int -> WindowPosition
AnotherWindowPosition Int
k
instance P.Ord WindowPosition where
compare :: WindowPosition -> WindowPosition -> Ordering
compare a :: WindowPosition
a b :: 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)
foreign import ccall "gtk_window_position_get_type" c_gtk_window_position_get_type ::
IO GType
instance BoxedEnum WindowPosition where
boxedEnumType :: WindowPosition -> IO GType
boxedEnumType _ = IO GType
c_gtk_window_position_get_type
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 WidgetHelpTypeTooltip = 0
fromEnum WidgetHelpTypeWhatsThis = 1
fromEnum (AnotherWidgetHelpType k :: Int
k) = Int
k
toEnum :: Int -> WidgetHelpType
toEnum 0 = WidgetHelpType
WidgetHelpTypeTooltip
toEnum 1 = WidgetHelpType
WidgetHelpTypeWhatsThis
toEnum k :: Int
k = Int -> WidgetHelpType
AnotherWidgetHelpType Int
k
instance P.Ord WidgetHelpType where
compare :: WidgetHelpType -> WidgetHelpType -> Ordering
compare a :: WidgetHelpType
a b :: 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)
foreign import ccall "gtk_widget_help_type_get_type" c_gtk_widget_help_type_get_type ::
IO GType
instance BoxedEnum WidgetHelpType where
boxedEnumType :: WidgetHelpType -> IO GType
boxedEnumType _ = IO GType
c_gtk_widget_help_type_get_type
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 UnitNone = 0
fromEnum UnitPoints = 1
fromEnum UnitInch = 2
fromEnum UnitMm = 3
fromEnum (AnotherUnit k :: Int
k) = Int
k
toEnum :: Int -> Unit
toEnum 0 = Unit
UnitNone
toEnum 1 = Unit
UnitPoints
toEnum 2 = Unit
UnitInch
toEnum 3 = Unit
UnitMm
toEnum k :: Int
k = Int -> Unit
AnotherUnit Int
k
instance P.Ord Unit where
compare :: Unit -> Unit -> Ordering
compare a :: Unit
a b :: 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)
foreign import ccall "gtk_unit_get_type" c_gtk_unit_get_type ::
IO GType
instance BoxedEnum Unit where
boxedEnumType :: Unit -> IO GType
boxedEnumType _ = IO GType
c_gtk_unit_get_type
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 TreeViewGridLinesNone = 0
fromEnum TreeViewGridLinesHorizontal = 1
fromEnum TreeViewGridLinesVertical = 2
fromEnum TreeViewGridLinesBoth = 3
fromEnum (AnotherTreeViewGridLines k :: Int
k) = Int
k
toEnum :: Int -> TreeViewGridLines
toEnum 0 = TreeViewGridLines
TreeViewGridLinesNone
toEnum 1 = TreeViewGridLines
TreeViewGridLinesHorizontal
toEnum 2 = TreeViewGridLines
TreeViewGridLinesVertical
toEnum 3 = TreeViewGridLines
TreeViewGridLinesBoth
toEnum k :: Int
k = Int -> TreeViewGridLines
AnotherTreeViewGridLines Int
k
instance P.Ord TreeViewGridLines where
compare :: TreeViewGridLines -> TreeViewGridLines -> Ordering
compare a :: TreeViewGridLines
a b :: 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)
foreign import ccall "gtk_tree_view_grid_lines_get_type" c_gtk_tree_view_grid_lines_get_type ::
IO GType
instance BoxedEnum TreeViewGridLines where
boxedEnumType :: TreeViewGridLines -> IO GType
boxedEnumType _ = IO GType
c_gtk_tree_view_grid_lines_get_type
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 TreeViewDropPositionBefore = 0
fromEnum TreeViewDropPositionAfter = 1
fromEnum TreeViewDropPositionIntoOrBefore = 2
fromEnum TreeViewDropPositionIntoOrAfter = 3
fromEnum (AnotherTreeViewDropPosition k :: Int
k) = Int
k
toEnum :: Int -> TreeViewDropPosition
toEnum 0 = TreeViewDropPosition
TreeViewDropPositionBefore
toEnum 1 = TreeViewDropPosition
TreeViewDropPositionAfter
toEnum 2 = TreeViewDropPosition
TreeViewDropPositionIntoOrBefore
toEnum 3 = TreeViewDropPosition
TreeViewDropPositionIntoOrAfter
toEnum k :: Int
k = Int -> TreeViewDropPosition
AnotherTreeViewDropPosition Int
k
instance P.Ord TreeViewDropPosition where
compare :: TreeViewDropPosition -> TreeViewDropPosition -> Ordering
compare a :: TreeViewDropPosition
a b :: 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)
foreign import ccall "gtk_tree_view_drop_position_get_type" c_gtk_tree_view_drop_position_get_type ::
IO GType
instance BoxedEnum TreeViewDropPosition where
boxedEnumType :: TreeViewDropPosition -> IO GType
boxedEnumType _ = IO GType
c_gtk_tree_view_drop_position_get_type
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 TreeViewColumnSizingGrowOnly = 0
fromEnum TreeViewColumnSizingAutosize = 1
fromEnum TreeViewColumnSizingFixed = 2
fromEnum (AnotherTreeViewColumnSizing k :: Int
k) = Int
k
toEnum :: Int -> TreeViewColumnSizing
toEnum 0 = TreeViewColumnSizing
TreeViewColumnSizingGrowOnly
toEnum 1 = TreeViewColumnSizing
TreeViewColumnSizingAutosize
toEnum 2 = TreeViewColumnSizing
TreeViewColumnSizingFixed
toEnum k :: Int
k = Int -> TreeViewColumnSizing
AnotherTreeViewColumnSizing Int
k
instance P.Ord TreeViewColumnSizing where
compare :: TreeViewColumnSizing -> TreeViewColumnSizing -> Ordering
compare a :: TreeViewColumnSizing
a b :: 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)
foreign import ccall "gtk_tree_view_column_sizing_get_type" c_gtk_tree_view_column_sizing_get_type ::
IO GType
instance BoxedEnum TreeViewColumnSizing where
boxedEnumType :: TreeViewColumnSizing -> IO GType
boxedEnumType _ = IO GType
c_gtk_tree_view_column_sizing_get_type
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 ToolbarStyleIcons = 0
fromEnum ToolbarStyleText = 1
fromEnum ToolbarStyleBoth = 2
fromEnum ToolbarStyleBothHoriz = 3
fromEnum (AnotherToolbarStyle k :: Int
k) = Int
k
toEnum :: Int -> ToolbarStyle
toEnum 0 = ToolbarStyle
ToolbarStyleIcons
toEnum 1 = ToolbarStyle
ToolbarStyleText
toEnum 2 = ToolbarStyle
ToolbarStyleBoth
toEnum 3 = ToolbarStyle
ToolbarStyleBothHoriz
toEnum k :: Int
k = Int -> ToolbarStyle
AnotherToolbarStyle Int
k
instance P.Ord ToolbarStyle where
compare :: ToolbarStyle -> ToolbarStyle -> Ordering
compare a :: ToolbarStyle
a b :: 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)
foreign import ccall "gtk_toolbar_style_get_type" c_gtk_toolbar_style_get_type ::
IO GType
instance BoxedEnum ToolbarStyle where
boxedEnumType :: ToolbarStyle -> IO GType
boxedEnumType _ = IO GType
c_gtk_toolbar_style_get_type
{-# 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 ToolbarSpaceStyleEmpty = 0
fromEnum ToolbarSpaceStyleLine = 1
fromEnum (AnotherToolbarSpaceStyle k :: Int
k) = Int
k
toEnum :: Int -> ToolbarSpaceStyle
toEnum 0 = ToolbarSpaceStyle
ToolbarSpaceStyleEmpty
toEnum 1 = ToolbarSpaceStyle
ToolbarSpaceStyleLine
toEnum k :: Int
k = Int -> ToolbarSpaceStyle
AnotherToolbarSpaceStyle Int
k
instance P.Ord ToolbarSpaceStyle where
compare :: ToolbarSpaceStyle -> ToolbarSpaceStyle -> Ordering
compare a :: ToolbarSpaceStyle
a b :: 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)
foreign import ccall "gtk_toolbar_space_style_get_type" c_gtk_toolbar_space_style_get_type ::
IO GType
instance BoxedEnum ToolbarSpaceStyle where
boxedEnumType :: ToolbarSpaceStyle -> IO GType
boxedEnumType _ = IO GType
c_gtk_toolbar_space_style_get_type
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 TextWindowTypePrivate = 0
fromEnum TextWindowTypeWidget = 1
fromEnum TextWindowTypeText = 2
fromEnum TextWindowTypeLeft = 3
fromEnum TextWindowTypeRight = 4
fromEnum TextWindowTypeTop = 5
fromEnum TextWindowTypeBottom = 6
fromEnum (AnotherTextWindowType k :: Int
k) = Int
k
toEnum :: Int -> TextWindowType
toEnum 0 = TextWindowType
TextWindowTypePrivate
toEnum 1 = TextWindowType
TextWindowTypeWidget
toEnum 2 = TextWindowType
TextWindowTypeText
toEnum 3 = TextWindowType
TextWindowTypeLeft
toEnum 4 = TextWindowType
TextWindowTypeRight
toEnum 5 = TextWindowType
TextWindowTypeTop
toEnum 6 = TextWindowType
TextWindowTypeBottom
toEnum k :: Int
k = Int -> TextWindowType
AnotherTextWindowType Int
k
instance P.Ord TextWindowType where
compare :: TextWindowType -> TextWindowType -> Ordering
compare a :: TextWindowType
a b :: 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)
foreign import ccall "gtk_text_window_type_get_type" c_gtk_text_window_type_get_type ::
IO GType
instance BoxedEnum TextWindowType where
boxedEnumType :: TextWindowType -> IO GType
boxedEnumType _ = IO GType
c_gtk_text_window_type_get_type
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 TextViewLayerBelow = 0
fromEnum TextViewLayerAbove = 1
fromEnum TextViewLayerBelowText = 2
fromEnum TextViewLayerAboveText = 3
fromEnum (AnotherTextViewLayer k :: Int
k) = Int
k
toEnum :: Int -> TextViewLayer
toEnum 0 = TextViewLayer
TextViewLayerBelow
toEnum 1 = TextViewLayer
TextViewLayerAbove
toEnum 2 = TextViewLayer
TextViewLayerBelowText
toEnum 3 = TextViewLayer
TextViewLayerAboveText
toEnum k :: Int
k = Int -> TextViewLayer
AnotherTextViewLayer Int
k
instance P.Ord TextViewLayer where
compare :: TextViewLayer -> TextViewLayer -> Ordering
compare a :: TextViewLayer
a b :: 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)
foreign import ccall "gtk_text_view_layer_get_type" c_gtk_text_view_layer_get_type ::
IO GType
instance BoxedEnum TextViewLayer where
boxedEnumType :: TextViewLayer -> IO GType
boxedEnumType _ = IO GType
c_gtk_text_view_layer_get_type
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 TextExtendSelectionWord = 0
fromEnum TextExtendSelectionLine = 1
fromEnum (AnotherTextExtendSelection k :: Int
k) = Int
k
toEnum :: Int -> TextExtendSelection
toEnum 0 = TextExtendSelection
TextExtendSelectionWord
toEnum 1 = TextExtendSelection
TextExtendSelectionLine
toEnum k :: Int
k = Int -> TextExtendSelection
AnotherTextExtendSelection Int
k
instance P.Ord TextExtendSelection where
compare :: TextExtendSelection -> TextExtendSelection -> Ordering
compare a :: TextExtendSelection
a b :: 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)
foreign import ccall "gtk_text_extend_selection_get_type" c_gtk_text_extend_selection_get_type ::
IO GType
instance BoxedEnum TextExtendSelection where
boxedEnumType :: TextExtendSelection -> IO GType
boxedEnumType _ = IO GType
c_gtk_text_extend_selection_get_type
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 TextDirectionNone = 0
fromEnum TextDirectionLtr = 1
fromEnum TextDirectionRtl = 2
fromEnum (AnotherTextDirection k :: Int
k) = Int
k
toEnum :: Int -> TextDirection
toEnum 0 = TextDirection
TextDirectionNone
toEnum 1 = TextDirection
TextDirectionLtr
toEnum 2 = TextDirection
TextDirectionRtl
toEnum k :: Int
k = Int -> TextDirection
AnotherTextDirection Int
k
instance P.Ord TextDirection where
compare :: TextDirection -> TextDirection -> Ordering
compare a :: TextDirection
a b :: 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)
foreign import ccall "gtk_text_direction_get_type" c_gtk_text_direction_get_type ::
IO GType
instance BoxedEnum TextDirection where
boxedEnumType :: TextDirection -> IO GType
boxedEnumType _ = IO GType
c_gtk_text_direction_get_type
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 TextBufferTargetInfoBufferContents = -1
fromEnum TextBufferTargetInfoRichText = -2
fromEnum TextBufferTargetInfoText = -3
fromEnum (AnotherTextBufferTargetInfo k :: Int
k) = Int
k
toEnum :: Int -> TextBufferTargetInfo
toEnum -1 = TextBufferTargetInfo
TextBufferTargetInfoBufferContents
toEnum -2 = TextBufferTargetInfo
TextBufferTargetInfoRichText
toEnum -3 = TextBufferTargetInfo
TextBufferTargetInfoText
toEnum k :: Int
k = Int -> TextBufferTargetInfo
AnotherTextBufferTargetInfo Int
k
instance P.Ord TextBufferTargetInfo where
compare :: TextBufferTargetInfo -> TextBufferTargetInfo -> Ordering
compare a :: TextBufferTargetInfo
a b :: 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)
foreign import ccall "gtk_text_buffer_target_info_get_type" c_gtk_text_buffer_target_info_get_type ::
IO GType
instance BoxedEnum TextBufferTargetInfo where
boxedEnumType :: TextBufferTargetInfo -> IO GType
boxedEnumType _ = IO GType
c_gtk_text_buffer_target_info_get_type
{-# 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 StateTypeNormal = 0
fromEnum StateTypeActive = 1
fromEnum StateTypePrelight = 2
fromEnum StateTypeSelected = 3
fromEnum StateTypeInsensitive = 4
fromEnum StateTypeInconsistent = 5
fromEnum StateTypeFocused = 6
fromEnum (AnotherStateType k :: Int
k) = Int
k
toEnum :: Int -> StateType
toEnum 0 = StateType
StateTypeNormal
toEnum 1 = StateType
StateTypeActive
toEnum 2 = StateType
StateTypePrelight
toEnum 3 = StateType
StateTypeSelected
toEnum 4 = StateType
StateTypeInsensitive
toEnum 5 = StateType
StateTypeInconsistent
toEnum 6 = StateType
StateTypeFocused
toEnum k :: Int
k = Int -> StateType
AnotherStateType Int
k
instance P.Ord StateType where
compare :: StateType -> StateType -> Ordering
compare a :: StateType
a b :: 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)
foreign import ccall "gtk_state_type_get_type" c_gtk_state_type_get_type ::
IO GType
instance BoxedEnum StateType where
boxedEnumType :: StateType -> IO GType
boxedEnumType _ = IO GType
c_gtk_state_type_get_type
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 StackTransitionTypeNone = 0
fromEnum StackTransitionTypeCrossfade = 1
fromEnum StackTransitionTypeSlideRight = 2
fromEnum StackTransitionTypeSlideLeft = 3
fromEnum StackTransitionTypeSlideUp = 4
fromEnum StackTransitionTypeSlideDown = 5
fromEnum StackTransitionTypeSlideLeftRight = 6
fromEnum StackTransitionTypeSlideUpDown = 7
fromEnum StackTransitionTypeOverUp = 8
fromEnum StackTransitionTypeOverDown = 9
fromEnum StackTransitionTypeOverLeft = 10
fromEnum StackTransitionTypeOverRight = 11
fromEnum StackTransitionTypeUnderUp = 12
fromEnum StackTransitionTypeUnderDown = 13
fromEnum StackTransitionTypeUnderLeft = 14
fromEnum StackTransitionTypeUnderRight = 15
fromEnum StackTransitionTypeOverUpDown = 16
fromEnum StackTransitionTypeOverDownUp = 17
fromEnum StackTransitionTypeOverLeftRight = 18
fromEnum StackTransitionTypeOverRightLeft = 19
fromEnum (AnotherStackTransitionType k :: Int
k) = Int
k
toEnum :: Int -> StackTransitionType
toEnum 0 = StackTransitionType
StackTransitionTypeNone
toEnum 1 = StackTransitionType
StackTransitionTypeCrossfade
toEnum 2 = StackTransitionType
StackTransitionTypeSlideRight
toEnum 3 = StackTransitionType
StackTransitionTypeSlideLeft
toEnum 4 = StackTransitionType
StackTransitionTypeSlideUp
toEnum 5 = StackTransitionType
StackTransitionTypeSlideDown
toEnum 6 = StackTransitionType
StackTransitionTypeSlideLeftRight
toEnum 7 = StackTransitionType
StackTransitionTypeSlideUpDown
toEnum 8 = StackTransitionType
StackTransitionTypeOverUp
toEnum 9 = StackTransitionType
StackTransitionTypeOverDown
toEnum 10 = StackTransitionType
StackTransitionTypeOverLeft
toEnum 11 = StackTransitionType
StackTransitionTypeOverRight
toEnum 12 = StackTransitionType
StackTransitionTypeUnderUp
toEnum 13 = StackTransitionType
StackTransitionTypeUnderDown
toEnum 14 = StackTransitionType
StackTransitionTypeUnderLeft
toEnum 15 = StackTransitionType
StackTransitionTypeUnderRight
toEnum 16 = StackTransitionType
StackTransitionTypeOverUpDown
toEnum 17 = StackTransitionType
StackTransitionTypeOverDownUp
toEnum 18 = StackTransitionType
StackTransitionTypeOverLeftRight
toEnum 19 = StackTransitionType
StackTransitionTypeOverRightLeft
toEnum k :: Int
k = Int -> StackTransitionType
AnotherStackTransitionType Int
k
instance P.Ord StackTransitionType where
compare :: StackTransitionType -> StackTransitionType -> Ordering
compare a :: StackTransitionType
a b :: 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)
foreign import ccall "gtk_stack_transition_type_get_type" c_gtk_stack_transition_type_get_type ::
IO GType
instance BoxedEnum StackTransitionType where
boxedEnumType :: StackTransitionType -> IO GType
boxedEnumType _ = IO GType
c_gtk_stack_transition_type_get_type
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 SpinTypeStepForward = 0
fromEnum SpinTypeStepBackward = 1
fromEnum SpinTypePageForward = 2
fromEnum SpinTypePageBackward = 3
fromEnum SpinTypeHome = 4
fromEnum SpinTypeEnd = 5
fromEnum SpinTypeUserDefined = 6
fromEnum (AnotherSpinType k :: Int
k) = Int
k
toEnum :: Int -> SpinType
toEnum 0 = SpinType
SpinTypeStepForward
toEnum 1 = SpinType
SpinTypeStepBackward
toEnum 2 = SpinType
SpinTypePageForward
toEnum 3 = SpinType
SpinTypePageBackward
toEnum 4 = SpinType
SpinTypeHome
toEnum 5 = SpinType
SpinTypeEnd
toEnum 6 = SpinType
SpinTypeUserDefined
toEnum k :: Int
k = Int -> SpinType
AnotherSpinType Int
k
instance P.Ord SpinType where
compare :: SpinType -> SpinType -> Ordering
compare a :: SpinType
a b :: 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)
foreign import ccall "gtk_spin_type_get_type" c_gtk_spin_type_get_type ::
IO GType
instance BoxedEnum SpinType where
boxedEnumType :: SpinType -> IO GType
boxedEnumType _ = IO GType
c_gtk_spin_type_get_type
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 SpinButtonUpdatePolicyAlways = 0
fromEnum SpinButtonUpdatePolicyIfValid = 1
fromEnum (AnotherSpinButtonUpdatePolicy k :: Int
k) = Int
k
toEnum :: Int -> SpinButtonUpdatePolicy
toEnum 0 = SpinButtonUpdatePolicy
SpinButtonUpdatePolicyAlways
toEnum 1 = SpinButtonUpdatePolicy
SpinButtonUpdatePolicyIfValid
toEnum k :: Int
k = Int -> SpinButtonUpdatePolicy
AnotherSpinButtonUpdatePolicy Int
k
instance P.Ord SpinButtonUpdatePolicy where
compare :: SpinButtonUpdatePolicy -> SpinButtonUpdatePolicy -> Ordering
compare a :: SpinButtonUpdatePolicy
a b :: 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)
foreign import ccall "gtk_spin_button_update_policy_get_type" c_gtk_spin_button_update_policy_get_type ::
IO GType
instance BoxedEnum SpinButtonUpdatePolicy where
boxedEnumType :: SpinButtonUpdatePolicy -> IO GType
boxedEnumType _ = IO GType
c_gtk_spin_button_update_policy_get_type
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 SortTypeAscending = 0
fromEnum SortTypeDescending = 1
fromEnum (AnotherSortType k :: Int
k) = Int
k
toEnum :: Int -> SortType
toEnum 0 = SortType
SortTypeAscending
toEnum 1 = SortType
SortTypeDescending
toEnum k :: Int
k = Int -> SortType
AnotherSortType Int
k
instance P.Ord SortType where
compare :: SortType -> SortType -> Ordering
compare a :: SortType
a b :: 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)
foreign import ccall "gtk_sort_type_get_type" c_gtk_sort_type_get_type ::
IO GType
instance BoxedEnum SortType where
boxedEnumType :: SortType -> IO GType
boxedEnumType _ = IO GType
c_gtk_sort_type_get_type
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 SizeRequestModeHeightForWidth = 0
fromEnum SizeRequestModeWidthForHeight = 1
fromEnum SizeRequestModeConstantSize = 2
fromEnum (AnotherSizeRequestMode k :: Int
k) = Int
k
toEnum :: Int -> SizeRequestMode
toEnum 0 = SizeRequestMode
SizeRequestModeHeightForWidth
toEnum 1 = SizeRequestMode
SizeRequestModeWidthForHeight
toEnum 2 = SizeRequestMode
SizeRequestModeConstantSize
toEnum k :: Int
k = Int -> SizeRequestMode
AnotherSizeRequestMode Int
k
instance P.Ord SizeRequestMode where
compare :: SizeRequestMode -> SizeRequestMode -> Ordering
compare a :: SizeRequestMode
a b :: 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)
foreign import ccall "gtk_size_request_mode_get_type" c_gtk_size_request_mode_get_type ::
IO GType
instance BoxedEnum SizeRequestMode where
boxedEnumType :: SizeRequestMode -> IO GType
boxedEnumType _ = IO GType
c_gtk_size_request_mode_get_type
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 SizeGroupModeNone = 0
fromEnum SizeGroupModeHorizontal = 1
fromEnum SizeGroupModeVertical = 2
fromEnum SizeGroupModeBoth = 3
fromEnum (AnotherSizeGroupMode k :: Int
k) = Int
k
toEnum :: Int -> SizeGroupMode
toEnum 0 = SizeGroupMode
SizeGroupModeNone
toEnum 1 = SizeGroupMode
SizeGroupModeHorizontal
toEnum 2 = SizeGroupMode
SizeGroupModeVertical
toEnum 3 = SizeGroupMode
SizeGroupModeBoth
toEnum k :: Int
k = Int -> SizeGroupMode
AnotherSizeGroupMode Int
k
instance P.Ord SizeGroupMode where
compare :: SizeGroupMode -> SizeGroupMode -> Ordering
compare a :: SizeGroupMode
a b :: 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)
foreign import ccall "gtk_size_group_mode_get_type" c_gtk_size_group_mode_get_type ::
IO GType
instance BoxedEnum SizeGroupMode where
boxedEnumType :: SizeGroupMode -> IO GType
boxedEnumType _ = IO GType
c_gtk_size_group_mode_get_type
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 ShortcutTypeAccelerator = 0
fromEnum ShortcutTypeGesturePinch = 1
fromEnum ShortcutTypeGestureStretch = 2
fromEnum ShortcutTypeGestureRotateClockwise = 3
fromEnum ShortcutTypeGestureRotateCounterclockwise = 4
fromEnum ShortcutTypeGestureTwoFingerSwipeLeft = 5
fromEnum ShortcutTypeGestureTwoFingerSwipeRight = 6
fromEnum ShortcutTypeGesture = 7
fromEnum (AnotherShortcutType k :: Int
k) = Int
k
toEnum :: Int -> ShortcutType
toEnum 0 = ShortcutType
ShortcutTypeAccelerator
toEnum 1 = ShortcutType
ShortcutTypeGesturePinch
toEnum 2 = ShortcutType
ShortcutTypeGestureStretch
toEnum 3 = ShortcutType
ShortcutTypeGestureRotateClockwise
toEnum 4 = ShortcutType
ShortcutTypeGestureRotateCounterclockwise
toEnum 5 = ShortcutType
ShortcutTypeGestureTwoFingerSwipeLeft
toEnum 6 = ShortcutType
ShortcutTypeGestureTwoFingerSwipeRight
toEnum 7 = ShortcutType
ShortcutTypeGesture
toEnum k :: Int
k = Int -> ShortcutType
AnotherShortcutType Int
k
instance P.Ord ShortcutType where
compare :: ShortcutType -> ShortcutType -> Ordering
compare a :: ShortcutType
a b :: 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)
foreign import ccall "gtk_shortcut_type_get_type" c_gtk_shortcut_type_get_type ::
IO GType
instance BoxedEnum ShortcutType where
boxedEnumType :: ShortcutType -> IO GType
boxedEnumType _ = IO GType
c_gtk_shortcut_type_get_type
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 ShadowTypeNone = 0
fromEnum ShadowTypeIn = 1
fromEnum ShadowTypeOut = 2
fromEnum ShadowTypeEtchedIn = 3
fromEnum ShadowTypeEtchedOut = 4
fromEnum (AnotherShadowType k :: Int
k) = Int
k
toEnum :: Int -> ShadowType
toEnum 0 = ShadowType
ShadowTypeNone
toEnum 1 = ShadowType
ShadowTypeIn
toEnum 2 = ShadowType
ShadowTypeOut
toEnum 3 = ShadowType
ShadowTypeEtchedIn
toEnum 4 = ShadowType
ShadowTypeEtchedOut
toEnum k :: Int
k = Int -> ShadowType
AnotherShadowType Int
k
instance P.Ord ShadowType where
compare :: ShadowType -> ShadowType -> Ordering
compare a :: ShadowType
a b :: 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)
foreign import ccall "gtk_shadow_type_get_type" c_gtk_shadow_type_get_type ::
IO GType
instance BoxedEnum ShadowType where
boxedEnumType :: ShadowType -> IO GType
boxedEnumType _ = IO GType
c_gtk_shadow_type_get_type
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 SensitivityTypeAuto = 0
fromEnum SensitivityTypeOn = 1
fromEnum SensitivityTypeOff = 2
fromEnum (AnotherSensitivityType k :: Int
k) = Int
k
toEnum :: Int -> SensitivityType
toEnum 0 = SensitivityType
SensitivityTypeAuto
toEnum 1 = SensitivityType
SensitivityTypeOn
toEnum 2 = SensitivityType
SensitivityTypeOff
toEnum k :: Int
k = Int -> SensitivityType
AnotherSensitivityType Int
k
instance P.Ord SensitivityType where
compare :: SensitivityType -> SensitivityType -> Ordering
compare a :: SensitivityType
a b :: 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)
foreign import ccall "gtk_sensitivity_type_get_type" c_gtk_sensitivity_type_get_type ::
IO GType
instance BoxedEnum SensitivityType where
boxedEnumType :: SensitivityType -> IO GType
boxedEnumType _ = IO GType
c_gtk_sensitivity_type_get_type
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 SelectionModeNone = 0
fromEnum SelectionModeSingle = 1
fromEnum SelectionModeBrowse = 2
fromEnum SelectionModeMultiple = 3
fromEnum (AnotherSelectionMode k :: Int
k) = Int
k
toEnum :: Int -> SelectionMode
toEnum 0 = SelectionMode
SelectionModeNone
toEnum 1 = SelectionMode
SelectionModeSingle
toEnum 2 = SelectionMode
SelectionModeBrowse
toEnum 3 = SelectionMode
SelectionModeMultiple
toEnum k :: Int
k = Int -> SelectionMode
AnotherSelectionMode Int
k
instance P.Ord SelectionMode where
compare :: SelectionMode -> SelectionMode -> Ordering
compare a :: SelectionMode
a b :: 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)
foreign import ccall "gtk_selection_mode_get_type" c_gtk_selection_mode_get_type ::
IO GType
instance BoxedEnum SelectionMode where
boxedEnumType :: SelectionMode -> IO GType
boxedEnumType _ = IO GType
c_gtk_selection_mode_get_type
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 ScrollablePolicyMinimum = 0
fromEnum ScrollablePolicyNatural = 1
fromEnum (AnotherScrollablePolicy k :: Int
k) = Int
k
toEnum :: Int -> ScrollablePolicy
toEnum 0 = ScrollablePolicy
ScrollablePolicyMinimum
toEnum 1 = ScrollablePolicy
ScrollablePolicyNatural
toEnum k :: Int
k = Int -> ScrollablePolicy
AnotherScrollablePolicy Int
k
instance P.Ord ScrollablePolicy where
compare :: ScrollablePolicy -> ScrollablePolicy -> Ordering
compare a :: ScrollablePolicy
a b :: 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)
foreign import ccall "gtk_scrollable_policy_get_type" c_gtk_scrollable_policy_get_type ::
IO GType
instance BoxedEnum ScrollablePolicy where
boxedEnumType :: ScrollablePolicy -> IO GType
boxedEnumType _ = IO GType
c_gtk_scrollable_policy_get_type
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 ScrollTypeNone = 0
fromEnum ScrollTypeJump = 1
fromEnum ScrollTypeStepBackward = 2
fromEnum ScrollTypeStepForward = 3
fromEnum ScrollTypePageBackward = 4
fromEnum ScrollTypePageForward = 5
fromEnum ScrollTypeStepUp = 6
fromEnum ScrollTypeStepDown = 7
fromEnum ScrollTypePageUp = 8
fromEnum ScrollTypePageDown = 9
fromEnum ScrollTypeStepLeft = 10
fromEnum ScrollTypeStepRight = 11
fromEnum ScrollTypePageLeft = 12
fromEnum ScrollTypePageRight = 13
fromEnum ScrollTypeStart = 14
fromEnum ScrollTypeEnd = 15
fromEnum (AnotherScrollType k :: Int
k) = Int
k
toEnum :: Int -> ScrollType
toEnum 0 = ScrollType
ScrollTypeNone
toEnum 1 = ScrollType
ScrollTypeJump
toEnum 2 = ScrollType
ScrollTypeStepBackward
toEnum 3 = ScrollType
ScrollTypeStepForward
toEnum 4 = ScrollType
ScrollTypePageBackward
toEnum 5 = ScrollType
ScrollTypePageForward
toEnum 6 = ScrollType
ScrollTypeStepUp
toEnum 7 = ScrollType
ScrollTypeStepDown
toEnum 8 = ScrollType
ScrollTypePageUp
toEnum 9 = ScrollType
ScrollTypePageDown
toEnum 10 = ScrollType
ScrollTypeStepLeft
toEnum 11 = ScrollType
ScrollTypeStepRight
toEnum 12 = ScrollType
ScrollTypePageLeft
toEnum 13 = ScrollType
ScrollTypePageRight
toEnum 14 = ScrollType
ScrollTypeStart
toEnum 15 = ScrollType
ScrollTypeEnd
toEnum k :: Int
k = Int -> ScrollType
AnotherScrollType Int
k
instance P.Ord ScrollType where
compare :: ScrollType -> ScrollType -> Ordering
compare a :: ScrollType
a b :: 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)
foreign import ccall "gtk_scroll_type_get_type" c_gtk_scroll_type_get_type ::
IO GType
instance BoxedEnum ScrollType where
boxedEnumType :: ScrollType -> IO GType
boxedEnumType _ = IO GType
c_gtk_scroll_type_get_type
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 ScrollStepSteps = 0
fromEnum ScrollStepPages = 1
fromEnum ScrollStepEnds = 2
fromEnum ScrollStepHorizontalSteps = 3
fromEnum ScrollStepHorizontalPages = 4
fromEnum ScrollStepHorizontalEnds = 5
fromEnum (AnotherScrollStep k :: Int
k) = Int
k
toEnum :: Int -> ScrollStep
toEnum 0 = ScrollStep
ScrollStepSteps
toEnum 1 = ScrollStep
ScrollStepPages
toEnum 2 = ScrollStep
ScrollStepEnds
toEnum 3 = ScrollStep
ScrollStepHorizontalSteps
toEnum 4 = ScrollStep
ScrollStepHorizontalPages
toEnum 5 = ScrollStep
ScrollStepHorizontalEnds
toEnum k :: Int
k = Int -> ScrollStep
AnotherScrollStep Int
k
instance P.Ord ScrollStep where
compare :: ScrollStep -> ScrollStep -> Ordering
compare a :: ScrollStep
a b :: 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)
foreign import ccall "gtk_scroll_step_get_type" c_gtk_scroll_step_get_type ::
IO GType
instance BoxedEnum ScrollStep where
boxedEnumType :: ScrollStep -> IO GType
boxedEnumType _ = IO GType
c_gtk_scroll_step_get_type
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 RevealerTransitionTypeNone = 0
fromEnum RevealerTransitionTypeCrossfade = 1
fromEnum RevealerTransitionTypeSlideRight = 2
fromEnum RevealerTransitionTypeSlideLeft = 3
fromEnum RevealerTransitionTypeSlideUp = 4
fromEnum RevealerTransitionTypeSlideDown = 5
fromEnum (AnotherRevealerTransitionType k :: Int
k) = Int
k
toEnum :: Int -> RevealerTransitionType
toEnum 0 = RevealerTransitionType
RevealerTransitionTypeNone
toEnum 1 = RevealerTransitionType
RevealerTransitionTypeCrossfade
toEnum 2 = RevealerTransitionType
RevealerTransitionTypeSlideRight
toEnum 3 = RevealerTransitionType
RevealerTransitionTypeSlideLeft
toEnum 4 = RevealerTransitionType
RevealerTransitionTypeSlideUp
toEnum 5 = RevealerTransitionType
RevealerTransitionTypeSlideDown
toEnum k :: Int
k = Int -> RevealerTransitionType
AnotherRevealerTransitionType Int
k
instance P.Ord RevealerTransitionType where
compare :: RevealerTransitionType -> RevealerTransitionType -> Ordering
compare a :: RevealerTransitionType
a b :: 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)
foreign import ccall "gtk_revealer_transition_type_get_type" c_gtk_revealer_transition_type_get_type ::
IO GType
instance BoxedEnum RevealerTransitionType where
boxedEnumType :: RevealerTransitionType -> IO GType
boxedEnumType _ = IO GType
c_gtk_revealer_transition_type_get_type
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 ResponseTypeNone = -1
fromEnum ResponseTypeReject = -2
fromEnum ResponseTypeAccept = -3
fromEnum ResponseTypeDeleteEvent = -4
fromEnum ResponseTypeOk = -5
fromEnum ResponseTypeCancel = -6
fromEnum ResponseTypeClose = -7
fromEnum ResponseTypeYes = -8
fromEnum ResponseTypeNo = -9
fromEnum ResponseTypeApply = -10
fromEnum ResponseTypeHelp = -11
fromEnum (AnotherResponseType k :: Int
k) = Int
k
toEnum :: Int -> ResponseType
toEnum -1 = ResponseType
ResponseTypeNone
toEnum -2 = ResponseType
ResponseTypeReject
toEnum -3 = ResponseType
ResponseTypeAccept
toEnum -4 = ResponseType
ResponseTypeDeleteEvent
toEnum -5 = ResponseType
ResponseTypeOk
toEnum -6 = ResponseType
ResponseTypeCancel
toEnum -7 = ResponseType
ResponseTypeClose
toEnum -8 = ResponseType
ResponseTypeYes
toEnum -9 = ResponseType
ResponseTypeNo
toEnum -10 = ResponseType
ResponseTypeApply
toEnum -11 = ResponseType
ResponseTypeHelp
toEnum k :: Int
k = Int -> ResponseType
AnotherResponseType Int
k
instance P.Ord ResponseType where
compare :: ResponseType -> ResponseType -> Ordering
compare a :: ResponseType
a b :: 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)
foreign import ccall "gtk_response_type_get_type" c_gtk_response_type_get_type ::
IO GType
instance BoxedEnum ResponseType where
boxedEnumType :: ResponseType -> IO GType
boxedEnumType _ = IO GType
c_gtk_response_type_get_type
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 ResizeModeParent = 0
fromEnum ResizeModeQueue = 1
fromEnum ResizeModeImmediate = 2
fromEnum (AnotherResizeMode k :: Int
k) = Int
k
toEnum :: Int -> ResizeMode
toEnum 0 = ResizeMode
ResizeModeParent
toEnum 1 = ResizeMode
ResizeModeQueue
toEnum 2 = ResizeMode
ResizeModeImmediate
toEnum k :: Int
k = Int -> ResizeMode
AnotherResizeMode Int
k
instance P.Ord ResizeMode where
compare :: ResizeMode -> ResizeMode -> Ordering
compare a :: ResizeMode
a b :: 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)
foreign import ccall "gtk_resize_mode_get_type" c_gtk_resize_mode_get_type ::
IO GType
instance BoxedEnum ResizeMode where
boxedEnumType :: ResizeMode -> IO GType
boxedEnumType _ = IO GType
c_gtk_resize_mode_get_type
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 ReliefStyleNormal = 0
fromEnum ReliefStyleHalf = 1
fromEnum ReliefStyleNone = 2
fromEnum (AnotherReliefStyle k :: Int
k) = Int
k
toEnum :: Int -> ReliefStyle
toEnum 0 = ReliefStyle
ReliefStyleNormal
toEnum 1 = ReliefStyle
ReliefStyleHalf
toEnum 2 = ReliefStyle
ReliefStyleNone
toEnum k :: Int
k = Int -> ReliefStyle
AnotherReliefStyle Int
k
instance P.Ord ReliefStyle where
compare :: ReliefStyle -> ReliefStyle -> Ordering
compare a :: ReliefStyle
a b :: 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)
foreign import ccall "gtk_relief_style_get_type" c_gtk_relief_style_get_type ::
IO GType
instance BoxedEnum ReliefStyle where
boxedEnumType :: ReliefStyle -> IO GType
boxedEnumType _ = IO GType
c_gtk_relief_style_get_type
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 RecentSortTypeNone = 0
fromEnum RecentSortTypeMru = 1
fromEnum RecentSortTypeLru = 2
fromEnum RecentSortTypeCustom = 3
fromEnum (AnotherRecentSortType k :: Int
k) = Int
k
toEnum :: Int -> RecentSortType
toEnum 0 = RecentSortType
RecentSortTypeNone
toEnum 1 = RecentSortType
RecentSortTypeMru
toEnum 2 = RecentSortType
RecentSortTypeLru
toEnum 3 = RecentSortType
RecentSortTypeCustom
toEnum k :: Int
k = Int -> RecentSortType
AnotherRecentSortType Int
k
instance P.Ord RecentSortType where
compare :: RecentSortType -> RecentSortType -> Ordering
compare a :: RecentSortType
a b :: 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)
foreign import ccall "gtk_recent_sort_type_get_type" c_gtk_recent_sort_type_get_type ::
IO GType
instance BoxedEnum RecentSortType where
boxedEnumType :: RecentSortType -> IO GType
boxedEnumType _ = IO GType
c_gtk_recent_sort_type_get_type
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 RecentManagerErrorNotFound = 0
fromEnum RecentManagerErrorInvalidUri = 1
fromEnum RecentManagerErrorInvalidEncoding = 2
fromEnum RecentManagerErrorNotRegistered = 3
fromEnum RecentManagerErrorRead = 4
fromEnum RecentManagerErrorWrite = 5
fromEnum RecentManagerErrorUnknown = 6
fromEnum (AnotherRecentManagerError k :: Int
k) = Int
k
toEnum :: Int -> RecentManagerError
toEnum 0 = RecentManagerError
RecentManagerErrorNotFound
toEnum 1 = RecentManagerError
RecentManagerErrorInvalidUri
toEnum 2 = RecentManagerError
RecentManagerErrorInvalidEncoding
toEnum 3 = RecentManagerError
RecentManagerErrorNotRegistered
toEnum 4 = RecentManagerError
RecentManagerErrorRead
toEnum 5 = RecentManagerError
RecentManagerErrorWrite
toEnum 6 = RecentManagerError
RecentManagerErrorUnknown
toEnum k :: Int
k = Int -> RecentManagerError
AnotherRecentManagerError Int
k
instance P.Ord RecentManagerError where
compare :: RecentManagerError -> RecentManagerError -> Ordering
compare a :: RecentManagerError
a b :: 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 _ = "gtk-recent-manager-error-quark"
catchRecentManagerError ::
IO a ->
(RecentManagerError -> GErrorMessage -> IO a) ->
IO a
catchRecentManagerError :: 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 :: (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
foreign import ccall "gtk_recent_manager_error_get_type" c_gtk_recent_manager_error_get_type ::
IO GType
instance BoxedEnum RecentManagerError where
boxedEnumType :: RecentManagerError -> IO GType
boxedEnumType _ = IO GType
c_gtk_recent_manager_error_get_type
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 RecentChooserErrorNotFound = 0
fromEnum RecentChooserErrorInvalidUri = 1
fromEnum (AnotherRecentChooserError k :: Int
k) = Int
k
toEnum :: Int -> RecentChooserError
toEnum 0 = RecentChooserError
RecentChooserErrorNotFound
toEnum 1 = RecentChooserError
RecentChooserErrorInvalidUri
toEnum k :: Int
k = Int -> RecentChooserError
AnotherRecentChooserError Int
k
instance P.Ord RecentChooserError where
compare :: RecentChooserError -> RecentChooserError -> Ordering
compare a :: RecentChooserError
a b :: 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 _ = "gtk-recent-chooser-error-quark"
catchRecentChooserError ::
IO a ->
(RecentChooserError -> GErrorMessage -> IO a) ->
IO a
catchRecentChooserError :: 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 :: (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
foreign import ccall "gtk_recent_chooser_error_get_type" c_gtk_recent_chooser_error_get_type ::
IO GType
instance BoxedEnum RecentChooserError where
boxedEnumType :: RecentChooserError -> IO GType
boxedEnumType _ = IO GType
c_gtk_recent_chooser_error_get_type
{-# 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 RcTokenTypeInvalid = 270
fromEnum RcTokenTypeInclude = 271
fromEnum RcTokenTypeNormal = 272
fromEnum RcTokenTypeActive = 273
fromEnum RcTokenTypePrelight = 274
fromEnum RcTokenTypeSelected = 275
fromEnum RcTokenTypeInsensitive = 276
fromEnum RcTokenTypeFg = 277
fromEnum RcTokenTypeBg = 278
fromEnum RcTokenTypeText = 279
fromEnum RcTokenTypeBase = 280
fromEnum RcTokenTypeXthickness = 281
fromEnum RcTokenTypeYthickness = 282
fromEnum RcTokenTypeFont = 283
fromEnum RcTokenTypeFontset = 284
fromEnum RcTokenTypeFontName = 285
fromEnum RcTokenTypeBgPixmap = 286
fromEnum RcTokenTypePixmapPath = 287
fromEnum RcTokenTypeStyle = 288
fromEnum RcTokenTypeBinding = 289
fromEnum RcTokenTypeBind = 290
fromEnum RcTokenTypeWidget = 291
fromEnum RcTokenTypeWidgetClass = 292
fromEnum RcTokenTypeClass = 293
fromEnum RcTokenTypeLowest = 294
fromEnum RcTokenTypeGtk = 295
fromEnum RcTokenTypeApplication = 296
fromEnum RcTokenTypeTheme = 297
fromEnum RcTokenTypeRc = 298
fromEnum RcTokenTypeHighest = 299
fromEnum RcTokenTypeEngine = 300
fromEnum RcTokenTypeModulePath = 301
fromEnum RcTokenTypeImModulePath = 302
fromEnum RcTokenTypeImModuleFile = 303
fromEnum RcTokenTypeStock = 304
fromEnum RcTokenTypeLtr = 305
fromEnum RcTokenTypeRtl = 306
fromEnum RcTokenTypeColor = 307
fromEnum RcTokenTypeUnbind = 308
fromEnum RcTokenTypeLast = 309
fromEnum (AnotherRcTokenType k :: Int
k) = Int
k
toEnum :: Int -> RcTokenType
toEnum 270 = RcTokenType
RcTokenTypeInvalid
toEnum 271 = RcTokenType
RcTokenTypeInclude
toEnum 272 = RcTokenType
RcTokenTypeNormal
toEnum 273 = RcTokenType
RcTokenTypeActive
toEnum 274 = RcTokenType
RcTokenTypePrelight
toEnum 275 = RcTokenType
RcTokenTypeSelected
toEnum 276 = RcTokenType
RcTokenTypeInsensitive
toEnum 277 = RcTokenType
RcTokenTypeFg
toEnum 278 = RcTokenType
RcTokenTypeBg
toEnum 279 = RcTokenType
RcTokenTypeText
toEnum 280 = RcTokenType
RcTokenTypeBase
toEnum 281 = RcTokenType
RcTokenTypeXthickness
toEnum 282 = RcTokenType
RcTokenTypeYthickness
toEnum 283 = RcTokenType
RcTokenTypeFont
toEnum 284 = RcTokenType
RcTokenTypeFontset
toEnum 285 = RcTokenType
RcTokenTypeFontName
toEnum 286 = RcTokenType
RcTokenTypeBgPixmap
toEnum 287 = RcTokenType
RcTokenTypePixmapPath
toEnum 288 = RcTokenType
RcTokenTypeStyle
toEnum 289 = RcTokenType
RcTokenTypeBinding
toEnum 290 = RcTokenType
RcTokenTypeBind
toEnum 291 = RcTokenType
RcTokenTypeWidget
toEnum 292 = RcTokenType
RcTokenTypeWidgetClass
toEnum 293 = RcTokenType
RcTokenTypeClass
toEnum 294 = RcTokenType
RcTokenTypeLowest
toEnum 295 = RcTokenType
RcTokenTypeGtk
toEnum 296 = RcTokenType
RcTokenTypeApplication
toEnum 297 = RcTokenType
RcTokenTypeTheme
toEnum 298 = RcTokenType
RcTokenTypeRc
toEnum 299 = RcTokenType
RcTokenTypeHighest
toEnum 300 = RcTokenType
RcTokenTypeEngine
toEnum 301 = RcTokenType
RcTokenTypeModulePath
toEnum 302 = RcTokenType
RcTokenTypeImModulePath
toEnum 303 = RcTokenType
RcTokenTypeImModuleFile
toEnum 304 = RcTokenType
RcTokenTypeStock
toEnum 305 = RcTokenType
RcTokenTypeLtr
toEnum 306 = RcTokenType
RcTokenTypeRtl
toEnum 307 = RcTokenType
RcTokenTypeColor
toEnum 308 = RcTokenType
RcTokenTypeUnbind
toEnum 309 = RcTokenType
RcTokenTypeLast
toEnum k :: Int
k = Int -> RcTokenType
AnotherRcTokenType Int
k
instance P.Ord RcTokenType where
compare :: RcTokenType -> RcTokenType -> Ordering
compare a :: RcTokenType
a b :: 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)
foreign import ccall "gtk_rc_token_type_get_type" c_gtk_rc_token_type_get_type ::
IO GType
instance BoxedEnum RcTokenType where
boxedEnumType :: RcTokenType -> IO GType
boxedEnumType _ = IO GType
c_gtk_rc_token_type_get_type
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 PropagationPhaseNone = 0
fromEnum PropagationPhaseCapture = 1
fromEnum PropagationPhaseBubble = 2
fromEnum PropagationPhaseTarget = 3
fromEnum (AnotherPropagationPhase k :: Int
k) = Int
k
toEnum :: Int -> PropagationPhase
toEnum 0 = PropagationPhase
PropagationPhaseNone
toEnum 1 = PropagationPhase
PropagationPhaseCapture
toEnum 2 = PropagationPhase
PropagationPhaseBubble
toEnum 3 = PropagationPhase
PropagationPhaseTarget
toEnum k :: Int
k = Int -> PropagationPhase
AnotherPropagationPhase Int
k
instance P.Ord PropagationPhase where
compare :: PropagationPhase -> PropagationPhase -> Ordering
compare a :: PropagationPhase
a b :: 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)
foreign import ccall "gtk_propagation_phase_get_type" c_gtk_propagation_phase_get_type ::
IO GType
instance BoxedEnum PropagationPhase where
boxedEnumType :: PropagationPhase -> IO GType
boxedEnumType _ = IO GType
c_gtk_propagation_phase_get_type
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 PrintStatusInitial = 0
fromEnum PrintStatusPreparing = 1
fromEnum PrintStatusGeneratingData = 2
fromEnum PrintStatusSendingData = 3
fromEnum PrintStatusPending = 4
fromEnum PrintStatusPendingIssue = 5
fromEnum PrintStatusPrinting = 6
fromEnum PrintStatusFinished = 7
fromEnum PrintStatusFinishedAborted = 8
fromEnum (AnotherPrintStatus k :: Int
k) = Int
k
toEnum :: Int -> PrintStatus
toEnum 0 = PrintStatus
PrintStatusInitial
toEnum 1 = PrintStatus
PrintStatusPreparing
toEnum 2 = PrintStatus
PrintStatusGeneratingData
toEnum 3 = PrintStatus
PrintStatusSendingData
toEnum 4 = PrintStatus
PrintStatusPending
toEnum 5 = PrintStatus
PrintStatusPendingIssue
toEnum 6 = PrintStatus
PrintStatusPrinting
toEnum 7 = PrintStatus
PrintStatusFinished
toEnum 8 = PrintStatus
PrintStatusFinishedAborted
toEnum k :: Int
k = Int -> PrintStatus
AnotherPrintStatus Int
k
instance P.Ord PrintStatus where
compare :: PrintStatus -> PrintStatus -> Ordering
compare a :: PrintStatus
a b :: 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)
foreign import ccall "gtk_print_status_get_type" c_gtk_print_status_get_type ::
IO GType
instance BoxedEnum PrintStatus where
boxedEnumType :: PrintStatus -> IO GType
boxedEnumType _ = IO GType
c_gtk_print_status_get_type
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 PrintQualityLow = 0
fromEnum PrintQualityNormal = 1
fromEnum PrintQualityHigh = 2
fromEnum PrintQualityDraft = 3
fromEnum (AnotherPrintQuality k :: Int
k) = Int
k
toEnum :: Int -> PrintQuality
toEnum 0 = PrintQuality
PrintQualityLow
toEnum 1 = PrintQuality
PrintQualityNormal
toEnum 2 = PrintQuality
PrintQualityHigh
toEnum 3 = PrintQuality
PrintQualityDraft
toEnum k :: Int
k = Int -> PrintQuality
AnotherPrintQuality Int
k
instance P.Ord PrintQuality where
compare :: PrintQuality -> PrintQuality -> Ordering
compare a :: PrintQuality
a b :: 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)
foreign import ccall "gtk_print_quality_get_type" c_gtk_print_quality_get_type ::
IO GType
instance BoxedEnum PrintQuality where
boxedEnumType :: PrintQuality -> IO GType
boxedEnumType _ = IO GType
c_gtk_print_quality_get_type
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 PrintPagesAll = 0
fromEnum PrintPagesCurrent = 1
fromEnum PrintPagesRanges = 2
fromEnum PrintPagesSelection = 3
fromEnum (AnotherPrintPages k :: Int
k) = Int
k
toEnum :: Int -> PrintPages
toEnum 0 = PrintPages
PrintPagesAll
toEnum 1 = PrintPages
PrintPagesCurrent
toEnum 2 = PrintPages
PrintPagesRanges
toEnum 3 = PrintPages
PrintPagesSelection
toEnum k :: Int
k = Int -> PrintPages
AnotherPrintPages Int
k
instance P.Ord PrintPages where
compare :: PrintPages -> PrintPages -> Ordering
compare a :: PrintPages
a b :: 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)
foreign import ccall "gtk_print_pages_get_type" c_gtk_print_pages_get_type ::
IO GType
instance BoxedEnum PrintPages where
boxedEnumType :: PrintPages -> IO GType
boxedEnumType _ = IO GType
c_gtk_print_pages_get_type
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 PrintOperationResultError = 0
fromEnum PrintOperationResultApply = 1
fromEnum PrintOperationResultCancel = 2
fromEnum PrintOperationResultInProgress = 3
fromEnum (AnotherPrintOperationResult k :: Int
k) = Int
k
toEnum :: Int -> PrintOperationResult
toEnum 0 = PrintOperationResult
PrintOperationResultError
toEnum 1 = PrintOperationResult
PrintOperationResultApply
toEnum 2 = PrintOperationResult
PrintOperationResultCancel
toEnum 3 = PrintOperationResult
PrintOperationResultInProgress
toEnum k :: Int
k = Int -> PrintOperationResult
AnotherPrintOperationResult Int
k
instance P.Ord PrintOperationResult where
compare :: PrintOperationResult -> PrintOperationResult -> Ordering
compare a :: PrintOperationResult
a b :: 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)
foreign import ccall "gtk_print_operation_result_get_type" c_gtk_print_operation_result_get_type ::
IO GType
instance BoxedEnum PrintOperationResult where
boxedEnumType :: PrintOperationResult -> IO GType
boxedEnumType _ = IO GType
c_gtk_print_operation_result_get_type
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 PrintOperationActionPrintDialog = 0
fromEnum PrintOperationActionPrint = 1
fromEnum PrintOperationActionPreview = 2
fromEnum PrintOperationActionExport = 3
fromEnum (AnotherPrintOperationAction k :: Int
k) = Int
k
toEnum :: Int -> PrintOperationAction
toEnum 0 = PrintOperationAction
PrintOperationActionPrintDialog
toEnum 1 = PrintOperationAction
PrintOperationActionPrint
toEnum 2 = PrintOperationAction
PrintOperationActionPreview
toEnum 3 = PrintOperationAction
PrintOperationActionExport
toEnum k :: Int
k = Int -> PrintOperationAction
AnotherPrintOperationAction Int
k
instance P.Ord PrintOperationAction where
compare :: PrintOperationAction -> PrintOperationAction -> Ordering
compare a :: PrintOperationAction
a b :: 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)
foreign import ccall "gtk_print_operation_action_get_type" c_gtk_print_operation_action_get_type ::
IO GType
instance BoxedEnum PrintOperationAction where
boxedEnumType :: PrintOperationAction -> IO GType
boxedEnumType _ = IO GType
c_gtk_print_operation_action_get_type
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 PrintErrorGeneral = 0
fromEnum PrintErrorInternalError = 1
fromEnum PrintErrorNomem = 2
fromEnum PrintErrorInvalidFile = 3
fromEnum (AnotherPrintError k :: Int
k) = Int
k
toEnum :: Int -> PrintError
toEnum 0 = PrintError
PrintErrorGeneral
toEnum 1 = PrintError
PrintErrorInternalError
toEnum 2 = PrintError
PrintErrorNomem
toEnum 3 = PrintError
PrintErrorInvalidFile
toEnum k :: Int
k = Int -> PrintError
AnotherPrintError Int
k
instance P.Ord PrintError where
compare :: PrintError -> PrintError -> Ordering
compare a :: PrintError
a b :: 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 _ = "gtk-print-error-quark"
catchPrintError ::
IO a ->
(PrintError -> GErrorMessage -> IO a) ->
IO a
catchPrintError :: 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 :: (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
foreign import ccall "gtk_print_error_get_type" c_gtk_print_error_get_type ::
IO GType
instance BoxedEnum PrintError where
boxedEnumType :: PrintError -> IO GType
boxedEnumType _ = IO GType
c_gtk_print_error_get_type
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 PrintDuplexSimplex = 0
fromEnum PrintDuplexHorizontal = 1
fromEnum PrintDuplexVertical = 2
fromEnum (AnotherPrintDuplex k :: Int
k) = Int
k
toEnum :: Int -> PrintDuplex
toEnum 0 = PrintDuplex
PrintDuplexSimplex
toEnum 1 = PrintDuplex
PrintDuplexHorizontal
toEnum 2 = PrintDuplex
PrintDuplexVertical
toEnum k :: Int
k = Int -> PrintDuplex
AnotherPrintDuplex Int
k
instance P.Ord PrintDuplex where
compare :: PrintDuplex -> PrintDuplex -> Ordering
compare a :: PrintDuplex
a b :: 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)
foreign import ccall "gtk_print_duplex_get_type" c_gtk_print_duplex_get_type ::
IO GType
instance BoxedEnum PrintDuplex where
boxedEnumType :: PrintDuplex -> IO GType
boxedEnumType _ = IO GType
c_gtk_print_duplex_get_type
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 PositionTypeLeft = 0
fromEnum PositionTypeRight = 1
fromEnum PositionTypeTop = 2
fromEnum PositionTypeBottom = 3
fromEnum (AnotherPositionType k :: Int
k) = Int
k
toEnum :: Int -> PositionType
toEnum 0 = PositionType
PositionTypeLeft
toEnum 1 = PositionType
PositionTypeRight
toEnum 2 = PositionType
PositionTypeTop
toEnum 3 = PositionType
PositionTypeBottom
toEnum k :: Int
k = Int -> PositionType
AnotherPositionType Int
k
instance P.Ord PositionType where
compare :: PositionType -> PositionType -> Ordering
compare a :: PositionType
a b :: 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)
foreign import ccall "gtk_position_type_get_type" c_gtk_position_type_get_type ::
IO GType
instance BoxedEnum PositionType where
boxedEnumType :: PositionType -> IO GType
boxedEnumType _ = IO GType
c_gtk_position_type_get_type
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 PopoverConstraintNone = 0
fromEnum PopoverConstraintWindow = 1
fromEnum (AnotherPopoverConstraint k :: Int
k) = Int
k
toEnum :: Int -> PopoverConstraint
toEnum 0 = PopoverConstraint
PopoverConstraintNone
toEnum 1 = PopoverConstraint
PopoverConstraintWindow
toEnum k :: Int
k = Int -> PopoverConstraint
AnotherPopoverConstraint Int
k
instance P.Ord PopoverConstraint where
compare :: PopoverConstraint -> PopoverConstraint -> Ordering
compare a :: PopoverConstraint
a b :: 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)
foreign import ccall "gtk_popover_constraint_get_type" c_gtk_popover_constraint_get_type ::
IO GType
instance BoxedEnum PopoverConstraint where
boxedEnumType :: PopoverConstraint -> IO GType
boxedEnumType _ = IO GType
c_gtk_popover_constraint_get_type
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 PolicyTypeAlways = 0
fromEnum PolicyTypeAutomatic = 1
fromEnum PolicyTypeNever = 2
fromEnum PolicyTypeExternal = 3
fromEnum (AnotherPolicyType k :: Int
k) = Int
k
toEnum :: Int -> PolicyType
toEnum 0 = PolicyType
PolicyTypeAlways
toEnum 1 = PolicyType
PolicyTypeAutomatic
toEnum 2 = PolicyType
PolicyTypeNever
toEnum 3 = PolicyType
PolicyTypeExternal
toEnum k :: Int
k = Int -> PolicyType
AnotherPolicyType Int
k
instance P.Ord PolicyType where
compare :: PolicyType -> PolicyType -> Ordering
compare a :: PolicyType
a b :: 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)
foreign import ccall "gtk_policy_type_get_type" c_gtk_policy_type_get_type ::
IO GType
instance BoxedEnum PolicyType where
boxedEnumType :: PolicyType -> IO GType
boxedEnumType _ = IO GType
c_gtk_policy_type_get_type
{-# 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 PathTypeWidget = 0
fromEnum PathTypeWidgetClass = 1
fromEnum PathTypeClass = 2
fromEnum (AnotherPathType k :: Int
k) = Int
k
toEnum :: Int -> PathType
toEnum 0 = PathType
PathTypeWidget
toEnum 1 = PathType
PathTypeWidgetClass
toEnum 2 = PathType
PathTypeClass
toEnum k :: Int
k = Int -> PathType
AnotherPathType Int
k
instance P.Ord PathType where
compare :: PathType -> PathType -> Ordering
compare a :: PathType
a b :: 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)
foreign import ccall "gtk_path_type_get_type" c_gtk_path_type_get_type ::
IO GType
instance BoxedEnum PathType where
boxedEnumType :: PathType -> IO GType
boxedEnumType _ = IO GType
c_gtk_path_type_get_type
{-# 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 PathPriorityTypeLowest = 0
fromEnum PathPriorityTypeGtk = 4
fromEnum PathPriorityTypeApplication = 8
fromEnum PathPriorityTypeTheme = 10
fromEnum PathPriorityTypeRc = 12
fromEnum PathPriorityTypeHighest = 15
fromEnum (AnotherPathPriorityType k :: Int
k) = Int
k
toEnum :: Int -> PathPriorityType
toEnum 0 = PathPriorityType
PathPriorityTypeLowest
toEnum 4 = PathPriorityType
PathPriorityTypeGtk
toEnum 8 = PathPriorityType
PathPriorityTypeApplication
toEnum 10 = PathPriorityType
PathPriorityTypeTheme
toEnum 12 = PathPriorityType
PathPriorityTypeRc
toEnum 15 = PathPriorityType
PathPriorityTypeHighest
toEnum k :: Int
k = Int -> PathPriorityType
AnotherPathPriorityType Int
k
instance P.Ord PathPriorityType where
compare :: PathPriorityType -> PathPriorityType -> Ordering
compare a :: PathPriorityType
a b :: 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)
foreign import ccall "gtk_path_priority_type_get_type" c_gtk_path_priority_type_get_type ::
IO GType
instance BoxedEnum PathPriorityType where
boxedEnumType :: PathPriorityType -> IO GType
boxedEnumType _ = IO GType
c_gtk_path_priority_type_get_type
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 PanDirectionLeft = 0
fromEnum PanDirectionRight = 1
fromEnum PanDirectionUp = 2
fromEnum PanDirectionDown = 3
fromEnum (AnotherPanDirection k :: Int
k) = Int
k
toEnum :: Int -> PanDirection
toEnum 0 = PanDirection
PanDirectionLeft
toEnum 1 = PanDirection
PanDirectionRight
toEnum 2 = PanDirection
PanDirectionUp
toEnum 3 = PanDirection
PanDirectionDown
toEnum k :: Int
k = Int -> PanDirection
AnotherPanDirection Int
k
instance P.Ord PanDirection where
compare :: PanDirection -> PanDirection -> Ordering
compare a :: PanDirection
a b :: 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)
foreign import ccall "gtk_pan_direction_get_type" c_gtk_pan_direction_get_type ::
IO GType
instance BoxedEnum PanDirection where
boxedEnumType :: PanDirection -> IO GType
boxedEnumType _ = IO GType
c_gtk_pan_direction_get_type
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 PageSetAll = 0
fromEnum PageSetEven = 1
fromEnum PageSetOdd = 2
fromEnum (AnotherPageSet k :: Int
k) = Int
k
toEnum :: Int -> PageSet
toEnum 0 = PageSet
PageSetAll
toEnum 1 = PageSet
PageSetEven
toEnum 2 = PageSet
PageSetOdd
toEnum k :: Int
k = Int -> PageSet
AnotherPageSet Int
k
instance P.Ord PageSet where
compare :: PageSet -> PageSet -> Ordering
compare a :: PageSet
a b :: 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)
foreign import ccall "gtk_page_set_get_type" c_gtk_page_set_get_type ::
IO GType
instance BoxedEnum PageSet where
boxedEnumType :: PageSet -> IO GType
boxedEnumType _ = IO GType
c_gtk_page_set_get_type
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 PageOrientationPortrait = 0
fromEnum PageOrientationLandscape = 1
fromEnum PageOrientationReversePortrait = 2
fromEnum PageOrientationReverseLandscape = 3
fromEnum (AnotherPageOrientation k :: Int
k) = Int
k
toEnum :: Int -> PageOrientation
toEnum 0 = PageOrientation
PageOrientationPortrait
toEnum 1 = PageOrientation
PageOrientationLandscape
toEnum 2 = PageOrientation
PageOrientationReversePortrait
toEnum 3 = PageOrientation
PageOrientationReverseLandscape
toEnum k :: Int
k = Int -> PageOrientation
AnotherPageOrientation Int
k
instance P.Ord PageOrientation where
compare :: PageOrientation -> PageOrientation -> Ordering
compare a :: PageOrientation
a b :: 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)
foreign import ccall "gtk_page_orientation_get_type" c_gtk_page_orientation_get_type ::
IO GType
instance BoxedEnum PageOrientation where
boxedEnumType :: PageOrientation -> IO GType
boxedEnumType _ = IO GType
c_gtk_page_orientation_get_type
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 PadActionTypeButton = 0
fromEnum PadActionTypeRing = 1
fromEnum PadActionTypeStrip = 2
fromEnum (AnotherPadActionType k :: Int
k) = Int
k
toEnum :: Int -> PadActionType
toEnum 0 = PadActionType
PadActionTypeButton
toEnum 1 = PadActionType
PadActionTypeRing
toEnum 2 = PadActionType
PadActionTypeStrip
toEnum k :: Int
k = Int -> PadActionType
AnotherPadActionType Int
k
instance P.Ord PadActionType where
compare :: PadActionType -> PadActionType -> Ordering
compare a :: PadActionType
a b :: 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)
foreign import ccall "gtk_pad_action_type_get_type" c_gtk_pad_action_type_get_type ::
IO GType
instance BoxedEnum PadActionType where
boxedEnumType :: PadActionType -> IO GType
boxedEnumType _ = IO GType
c_gtk_pad_action_type_get_type
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 PackTypeStart = 0
fromEnum PackTypeEnd = 1
fromEnum (AnotherPackType k :: Int
k) = Int
k
toEnum :: Int -> PackType
toEnum 0 = PackType
PackTypeStart
toEnum 1 = PackType
PackTypeEnd
toEnum k :: Int
k = Int -> PackType
AnotherPackType Int
k
instance P.Ord PackType where
compare :: PackType -> PackType -> Ordering
compare a :: PackType
a b :: 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)
foreign import ccall "gtk_pack_type_get_type" c_gtk_pack_type_get_type ::
IO GType
instance BoxedEnum PackType where
boxedEnumType :: PackType -> IO GType
boxedEnumType _ = IO GType
c_gtk_pack_type_get_type
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 PackDirectionLtr = 0
fromEnum PackDirectionRtl = 1
fromEnum PackDirectionTtb = 2
fromEnum PackDirectionBtt = 3
fromEnum (AnotherPackDirection k :: Int
k) = Int
k
toEnum :: Int -> PackDirection
toEnum 0 = PackDirection
PackDirectionLtr
toEnum 1 = PackDirection
PackDirectionRtl
toEnum 2 = PackDirection
PackDirectionTtb
toEnum 3 = PackDirection
PackDirectionBtt
toEnum k :: Int
k = Int -> PackDirection
AnotherPackDirection Int
k
instance P.Ord PackDirection where
compare :: PackDirection -> PackDirection -> Ordering
compare a :: PackDirection
a b :: 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)
foreign import ccall "gtk_pack_direction_get_type" c_gtk_pack_direction_get_type ::
IO GType
instance BoxedEnum PackDirection where
boxedEnumType :: PackDirection -> IO GType
boxedEnumType _ = IO GType
c_gtk_pack_direction_get_type
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 OrientationHorizontal = 0
fromEnum OrientationVertical = 1
fromEnum (AnotherOrientation k :: Int
k) = Int
k
toEnum :: Int -> Orientation
toEnum 0 = Orientation
OrientationHorizontal
toEnum 1 = Orientation
OrientationVertical
toEnum k :: Int
k = Int -> Orientation
AnotherOrientation Int
k
instance P.Ord Orientation where
compare :: Orientation -> Orientation -> Ordering
compare a :: Orientation
a b :: 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)
foreign import ccall "gtk_orientation_get_type" c_gtk_orientation_get_type ::
IO GType
instance BoxedEnum Orientation where
boxedEnumType :: Orientation -> IO GType
boxedEnumType _ = IO GType
c_gtk_orientation_get_type
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 NumberUpLayoutLrtb = 0
fromEnum NumberUpLayoutLrbt = 1