#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gtk.Enums
(
AccessibleAutocomplete(..) ,
AccessibleInvalidState(..) ,
AccessibleProperty(..) ,
AccessibleRelation(..) ,
AccessibleRole(..) ,
AccessibleSort(..) ,
AccessibleState(..) ,
AccessibleTristate(..) ,
Align(..) ,
ArrowType(..) ,
AssistantPageType(..) ,
BaselinePosition(..) ,
BorderStyle(..) ,
BuilderError(..) ,
catchBuilderError ,
handleBuilderError ,
ButtonsType(..) ,
CellRendererAccelMode(..) ,
CellRendererMode(..) ,
ConstraintAttribute(..) ,
ConstraintRelation(..) ,
ConstraintStrength(..) ,
ConstraintVflParserError(..) ,
catchConstraintVflParserError ,
handleConstraintVflParserError ,
CornerType(..) ,
CssParserError(..) ,
catchCssParserError ,
handleCssParserError ,
CssParserWarning(..) ,
DeleteType(..) ,
DirectionType(..) ,
EditableProperties(..) ,
EntryIconPosition(..) ,
EventSequenceState(..) ,
FileChooserAction(..) ,
FileChooserError(..) ,
catchFileChooserError ,
handleFileChooserError ,
FilterChange(..) ,
FilterMatch(..) ,
IconSize(..) ,
IconThemeError(..) ,
catchIconThemeError ,
handleIconThemeError ,
IconViewDropPosition(..) ,
ImageType(..) ,
InputPurpose(..) ,
Justification(..) ,
LevelBarMode(..) ,
License(..) ,
MessageType(..) ,
MovementStep(..) ,
NotebookTab(..) ,
NumberUpLayout(..) ,
Ordering(..) ,
Orientation(..) ,
Overflow(..) ,
PackType(..) ,
PadActionType(..) ,
PageOrientation(..) ,
PageSet(..) ,
PanDirection(..) ,
PolicyType(..) ,
PositionType(..) ,
PrintDuplex(..) ,
PrintError(..) ,
catchPrintError ,
handlePrintError ,
PrintOperationAction(..) ,
PrintOperationResult(..) ,
PrintPages(..) ,
PrintQuality(..) ,
PrintStatus(..) ,
PropagationLimit(..) ,
PropagationPhase(..) ,
RecentManagerError(..) ,
catchRecentManagerError ,
handleRecentManagerError ,
ResponseType(..) ,
RevealerTransitionType(..) ,
ScrollStep(..) ,
ScrollType(..) ,
ScrollablePolicy(..) ,
SelectionMode(..) ,
SensitivityType(..) ,
ShortcutScope(..) ,
ShortcutType(..) ,
SizeGroupMode(..) ,
SizeRequestMode(..) ,
SortType(..) ,
SorterChange(..) ,
SorterOrder(..) ,
SpinButtonUpdatePolicy(..) ,
SpinType(..) ,
StackTransitionType(..) ,
StringFilterMatchMode(..) ,
SystemSetting(..) ,
TextDirection(..) ,
TextExtendSelection(..) ,
TextViewLayer(..) ,
TextWindowType(..) ,
TreeViewColumnSizing(..) ,
TreeViewDropPosition(..) ,
TreeViewGridLines(..) ,
Unit(..) ,
WrapMode(..) ,
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R
data WrapMode =
WrapModeNone
| WrapModeChar
| WrapModeWord
| WrapModeWordChar
| AnotherWrapMode Int
deriving (Int -> WrapMode -> ShowS
[WrapMode] -> ShowS
WrapMode -> String
(Int -> WrapMode -> ShowS)
-> (WrapMode -> String) -> ([WrapMode] -> ShowS) -> Show WrapMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [WrapMode] -> ShowS
$cshowList :: [WrapMode] -> ShowS
show :: WrapMode -> String
$cshow :: WrapMode -> String
showsPrec :: Int -> WrapMode -> ShowS
$cshowsPrec :: Int -> WrapMode -> ShowS
Show, WrapMode -> WrapMode -> Bool
(WrapMode -> WrapMode -> Bool)
-> (WrapMode -> WrapMode -> Bool) -> Eq WrapMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: WrapMode -> WrapMode -> Bool
$c/= :: WrapMode -> WrapMode -> Bool
== :: WrapMode -> WrapMode -> Bool
$c== :: WrapMode -> WrapMode -> Bool
Eq)
instance P.Enum WrapMode where
fromEnum :: WrapMode -> Int
fromEnum WrapMode
WrapModeNone = Int
0
fromEnum WrapMode
WrapModeChar = Int
1
fromEnum WrapMode
WrapModeWord = Int
2
fromEnum WrapMode
WrapModeWordChar = Int
3
fromEnum (AnotherWrapMode Int
k) = Int
k
toEnum :: Int -> WrapMode
toEnum Int
0 = WrapMode
WrapModeNone
toEnum Int
1 = WrapMode
WrapModeChar
toEnum Int
2 = WrapMode
WrapModeWord
toEnum Int
3 = WrapMode
WrapModeWordChar
toEnum Int
k = Int -> WrapMode
AnotherWrapMode Int
k
instance P.Ord WrapMode where
compare :: WrapMode -> WrapMode -> Ordering
compare WrapMode
a WrapMode
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (WrapMode -> Int
forall a. Enum a => a -> Int
P.fromEnum WrapMode
a) (WrapMode -> Int
forall a. Enum a => a -> Int
P.fromEnum WrapMode
b)
type instance O.ParentTypes WrapMode = '[]
instance O.HasParentTypes WrapMode
foreign import ccall "gtk_wrap_mode_get_type" c_gtk_wrap_mode_get_type ::
IO GType
instance B.Types.TypedObject WrapMode where
glibType :: IO GType
glibType = IO GType
c_gtk_wrap_mode_get_type
instance B.Types.BoxedEnum WrapMode
data Unit =
UnitNone
| UnitPoints
| UnitInch
| UnitMm
| AnotherUnit Int
deriving (Int -> Unit -> ShowS
[Unit] -> ShowS
Unit -> String
(Int -> Unit -> ShowS)
-> (Unit -> String) -> ([Unit] -> ShowS) -> Show Unit
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Unit] -> ShowS
$cshowList :: [Unit] -> ShowS
show :: Unit -> String
$cshow :: Unit -> String
showsPrec :: Int -> Unit -> ShowS
$cshowsPrec :: Int -> Unit -> ShowS
Show, Unit -> Unit -> Bool
(Unit -> Unit -> Bool) -> (Unit -> Unit -> Bool) -> Eq Unit
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Unit -> Unit -> Bool
$c/= :: Unit -> Unit -> Bool
== :: Unit -> Unit -> Bool
$c== :: Unit -> Unit -> Bool
Eq)
instance P.Enum Unit where
fromEnum :: Unit -> Int
fromEnum Unit
UnitNone = Int
0
fromEnum Unit
UnitPoints = Int
1
fromEnum Unit
UnitInch = Int
2
fromEnum Unit
UnitMm = Int
3
fromEnum (AnotherUnit Int
k) = Int
k
toEnum :: Int -> Unit
toEnum Int
0 = Unit
UnitNone
toEnum Int
1 = Unit
UnitPoints
toEnum Int
2 = Unit
UnitInch
toEnum Int
3 = Unit
UnitMm
toEnum Int
k = Int -> Unit
AnotherUnit Int
k
instance P.Ord Unit where
compare :: Unit -> Unit -> Ordering
compare Unit
a Unit
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (Unit -> Int
forall a. Enum a => a -> Int
P.fromEnum Unit
a) (Unit -> Int
forall a. Enum a => a -> Int
P.fromEnum Unit
b)
type instance O.ParentTypes Unit = '[]
instance O.HasParentTypes Unit
foreign import ccall "gtk_unit_get_type" c_gtk_unit_get_type ::
IO GType
instance B.Types.TypedObject Unit where
glibType :: IO GType
glibType = IO GType
c_gtk_unit_get_type
instance B.Types.BoxedEnum Unit
data TreeViewGridLines =
TreeViewGridLinesNone
| TreeViewGridLinesHorizontal
| TreeViewGridLinesVertical
| TreeViewGridLinesBoth
| AnotherTreeViewGridLines Int
deriving (Int -> TreeViewGridLines -> ShowS
[TreeViewGridLines] -> ShowS
TreeViewGridLines -> String
(Int -> TreeViewGridLines -> ShowS)
-> (TreeViewGridLines -> String)
-> ([TreeViewGridLines] -> ShowS)
-> Show TreeViewGridLines
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TreeViewGridLines] -> ShowS
$cshowList :: [TreeViewGridLines] -> ShowS
show :: TreeViewGridLines -> String
$cshow :: TreeViewGridLines -> String
showsPrec :: Int -> TreeViewGridLines -> ShowS
$cshowsPrec :: Int -> TreeViewGridLines -> ShowS
Show, TreeViewGridLines -> TreeViewGridLines -> Bool
(TreeViewGridLines -> TreeViewGridLines -> Bool)
-> (TreeViewGridLines -> TreeViewGridLines -> Bool)
-> Eq TreeViewGridLines
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TreeViewGridLines -> TreeViewGridLines -> Bool
$c/= :: TreeViewGridLines -> TreeViewGridLines -> Bool
== :: TreeViewGridLines -> TreeViewGridLines -> Bool
$c== :: TreeViewGridLines -> TreeViewGridLines -> Bool
Eq)
instance P.Enum TreeViewGridLines where
fromEnum :: TreeViewGridLines -> Int
fromEnum TreeViewGridLines
TreeViewGridLinesNone = Int
0
fromEnum TreeViewGridLines
TreeViewGridLinesHorizontal = Int
1
fromEnum TreeViewGridLines
TreeViewGridLinesVertical = Int
2
fromEnum TreeViewGridLines
TreeViewGridLinesBoth = Int
3
fromEnum (AnotherTreeViewGridLines Int
k) = Int
k
toEnum :: Int -> TreeViewGridLines
toEnum Int
0 = TreeViewGridLines
TreeViewGridLinesNone
toEnum Int
1 = TreeViewGridLines
TreeViewGridLinesHorizontal
toEnum Int
2 = TreeViewGridLines
TreeViewGridLinesVertical
toEnum Int
3 = TreeViewGridLines
TreeViewGridLinesBoth
toEnum Int
k = Int -> TreeViewGridLines
AnotherTreeViewGridLines Int
k
instance P.Ord TreeViewGridLines where
compare :: TreeViewGridLines -> TreeViewGridLines -> Ordering
compare TreeViewGridLines
a TreeViewGridLines
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (TreeViewGridLines -> Int
forall a. Enum a => a -> Int
P.fromEnum TreeViewGridLines
a) (TreeViewGridLines -> Int
forall a. Enum a => a -> Int
P.fromEnum TreeViewGridLines
b)
type instance O.ParentTypes TreeViewGridLines = '[]
instance O.HasParentTypes TreeViewGridLines
foreign import ccall "gtk_tree_view_grid_lines_get_type" c_gtk_tree_view_grid_lines_get_type ::
IO GType
instance B.Types.TypedObject TreeViewGridLines where
glibType :: IO GType
glibType = IO GType
c_gtk_tree_view_grid_lines_get_type
instance B.Types.BoxedEnum TreeViewGridLines
data TreeViewDropPosition =
TreeViewDropPositionBefore
| TreeViewDropPositionAfter
| TreeViewDropPositionIntoOrBefore
| TreeViewDropPositionIntoOrAfter
| AnotherTreeViewDropPosition Int
deriving (Int -> TreeViewDropPosition -> ShowS
[TreeViewDropPosition] -> ShowS
TreeViewDropPosition -> String
(Int -> TreeViewDropPosition -> ShowS)
-> (TreeViewDropPosition -> String)
-> ([TreeViewDropPosition] -> ShowS)
-> Show TreeViewDropPosition
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TreeViewDropPosition] -> ShowS
$cshowList :: [TreeViewDropPosition] -> ShowS
show :: TreeViewDropPosition -> String
$cshow :: TreeViewDropPosition -> String
showsPrec :: Int -> TreeViewDropPosition -> ShowS
$cshowsPrec :: Int -> TreeViewDropPosition -> ShowS
Show, TreeViewDropPosition -> TreeViewDropPosition -> Bool
(TreeViewDropPosition -> TreeViewDropPosition -> Bool)
-> (TreeViewDropPosition -> TreeViewDropPosition -> Bool)
-> Eq TreeViewDropPosition
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TreeViewDropPosition -> TreeViewDropPosition -> Bool
$c/= :: TreeViewDropPosition -> TreeViewDropPosition -> Bool
== :: TreeViewDropPosition -> TreeViewDropPosition -> Bool
$c== :: TreeViewDropPosition -> TreeViewDropPosition -> Bool
Eq)
instance P.Enum TreeViewDropPosition where
fromEnum :: TreeViewDropPosition -> Int
fromEnum TreeViewDropPosition
TreeViewDropPositionBefore = Int
0
fromEnum TreeViewDropPosition
TreeViewDropPositionAfter = Int
1
fromEnum TreeViewDropPosition
TreeViewDropPositionIntoOrBefore = Int
2
fromEnum TreeViewDropPosition
TreeViewDropPositionIntoOrAfter = Int
3
fromEnum (AnotherTreeViewDropPosition Int
k) = Int
k
toEnum :: Int -> TreeViewDropPosition
toEnum Int
0 = TreeViewDropPosition
TreeViewDropPositionBefore
toEnum Int
1 = TreeViewDropPosition
TreeViewDropPositionAfter
toEnum Int
2 = TreeViewDropPosition
TreeViewDropPositionIntoOrBefore
toEnum Int
3 = TreeViewDropPosition
TreeViewDropPositionIntoOrAfter
toEnum Int
k = Int -> TreeViewDropPosition
AnotherTreeViewDropPosition Int
k
instance P.Ord TreeViewDropPosition where
compare :: TreeViewDropPosition -> TreeViewDropPosition -> Ordering
compare TreeViewDropPosition
a TreeViewDropPosition
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (TreeViewDropPosition -> Int
forall a. Enum a => a -> Int
P.fromEnum TreeViewDropPosition
a) (TreeViewDropPosition -> Int
forall a. Enum a => a -> Int
P.fromEnum TreeViewDropPosition
b)
type instance O.ParentTypes TreeViewDropPosition = '[]
instance O.HasParentTypes TreeViewDropPosition
foreign import ccall "gtk_tree_view_drop_position_get_type" c_gtk_tree_view_drop_position_get_type ::
IO GType
instance B.Types.TypedObject TreeViewDropPosition where
glibType :: IO GType
glibType = IO GType
c_gtk_tree_view_drop_position_get_type
instance B.Types.BoxedEnum TreeViewDropPosition
data TreeViewColumnSizing =
TreeViewColumnSizingGrowOnly
| TreeViewColumnSizingAutosize
| TreeViewColumnSizingFixed
| AnotherTreeViewColumnSizing Int
deriving (Int -> TreeViewColumnSizing -> ShowS
[TreeViewColumnSizing] -> ShowS
TreeViewColumnSizing -> String
(Int -> TreeViewColumnSizing -> ShowS)
-> (TreeViewColumnSizing -> String)
-> ([TreeViewColumnSizing] -> ShowS)
-> Show TreeViewColumnSizing
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TreeViewColumnSizing] -> ShowS
$cshowList :: [TreeViewColumnSizing] -> ShowS
show :: TreeViewColumnSizing -> String
$cshow :: TreeViewColumnSizing -> String
showsPrec :: Int -> TreeViewColumnSizing -> ShowS
$cshowsPrec :: Int -> TreeViewColumnSizing -> ShowS
Show, TreeViewColumnSizing -> TreeViewColumnSizing -> Bool
(TreeViewColumnSizing -> TreeViewColumnSizing -> Bool)
-> (TreeViewColumnSizing -> TreeViewColumnSizing -> Bool)
-> Eq TreeViewColumnSizing
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TreeViewColumnSizing -> TreeViewColumnSizing -> Bool
$c/= :: TreeViewColumnSizing -> TreeViewColumnSizing -> Bool
== :: TreeViewColumnSizing -> TreeViewColumnSizing -> Bool
$c== :: TreeViewColumnSizing -> TreeViewColumnSizing -> Bool
Eq)
instance P.Enum TreeViewColumnSizing where
fromEnum :: TreeViewColumnSizing -> Int
fromEnum TreeViewColumnSizing
TreeViewColumnSizingGrowOnly = Int
0
fromEnum TreeViewColumnSizing
TreeViewColumnSizingAutosize = Int
1
fromEnum TreeViewColumnSizing
TreeViewColumnSizingFixed = Int
2
fromEnum (AnotherTreeViewColumnSizing Int
k) = Int
k
toEnum :: Int -> TreeViewColumnSizing
toEnum Int
0 = TreeViewColumnSizing
TreeViewColumnSizingGrowOnly
toEnum Int
1 = TreeViewColumnSizing
TreeViewColumnSizingAutosize
toEnum Int
2 = TreeViewColumnSizing
TreeViewColumnSizingFixed
toEnum Int
k = Int -> TreeViewColumnSizing
AnotherTreeViewColumnSizing Int
k
instance P.Ord TreeViewColumnSizing where
compare :: TreeViewColumnSizing -> TreeViewColumnSizing -> Ordering
compare TreeViewColumnSizing
a TreeViewColumnSizing
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (TreeViewColumnSizing -> Int
forall a. Enum a => a -> Int
P.fromEnum TreeViewColumnSizing
a) (TreeViewColumnSizing -> Int
forall a. Enum a => a -> Int
P.fromEnum TreeViewColumnSizing
b)
type instance O.ParentTypes TreeViewColumnSizing = '[]
instance O.HasParentTypes TreeViewColumnSizing
foreign import ccall "gtk_tree_view_column_sizing_get_type" c_gtk_tree_view_column_sizing_get_type ::
IO GType
instance B.Types.TypedObject TreeViewColumnSizing where
glibType :: IO GType
glibType = IO GType
c_gtk_tree_view_column_sizing_get_type
instance B.Types.BoxedEnum TreeViewColumnSizing
data TextWindowType =
TextWindowTypeWidget
| TextWindowTypeText
| TextWindowTypeLeft
| TextWindowTypeRight
| TextWindowTypeTop
| TextWindowTypeBottom
| AnotherTextWindowType Int
deriving (Int -> TextWindowType -> ShowS
[TextWindowType] -> ShowS
TextWindowType -> String
(Int -> TextWindowType -> ShowS)
-> (TextWindowType -> String)
-> ([TextWindowType] -> ShowS)
-> Show TextWindowType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TextWindowType] -> ShowS
$cshowList :: [TextWindowType] -> ShowS
show :: TextWindowType -> String
$cshow :: TextWindowType -> String
showsPrec :: Int -> TextWindowType -> ShowS
$cshowsPrec :: Int -> TextWindowType -> ShowS
Show, TextWindowType -> TextWindowType -> Bool
(TextWindowType -> TextWindowType -> Bool)
-> (TextWindowType -> TextWindowType -> Bool) -> Eq TextWindowType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TextWindowType -> TextWindowType -> Bool
$c/= :: TextWindowType -> TextWindowType -> Bool
== :: TextWindowType -> TextWindowType -> Bool
$c== :: TextWindowType -> TextWindowType -> Bool
Eq)
instance P.Enum TextWindowType where
fromEnum :: TextWindowType -> Int
fromEnum TextWindowType
TextWindowTypeWidget = Int
1
fromEnum TextWindowType
TextWindowTypeText = Int
2
fromEnum TextWindowType
TextWindowTypeLeft = Int
3
fromEnum TextWindowType
TextWindowTypeRight = Int
4
fromEnum TextWindowType
TextWindowTypeTop = Int
5
fromEnum TextWindowType
TextWindowTypeBottom = Int
6
fromEnum (AnotherTextWindowType Int
k) = Int
k
toEnum :: Int -> TextWindowType
toEnum Int
1 = TextWindowType
TextWindowTypeWidget
toEnum Int
2 = TextWindowType
TextWindowTypeText
toEnum Int
3 = TextWindowType
TextWindowTypeLeft
toEnum Int
4 = TextWindowType
TextWindowTypeRight
toEnum Int
5 = TextWindowType
TextWindowTypeTop
toEnum Int
6 = TextWindowType
TextWindowTypeBottom
toEnum Int
k = Int -> TextWindowType
AnotherTextWindowType Int
k
instance P.Ord TextWindowType where
compare :: TextWindowType -> TextWindowType -> Ordering
compare TextWindowType
a TextWindowType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (TextWindowType -> Int
forall a. Enum a => a -> Int
P.fromEnum TextWindowType
a) (TextWindowType -> Int
forall a. Enum a => a -> Int
P.fromEnum TextWindowType
b)
type instance O.ParentTypes TextWindowType = '[]
instance O.HasParentTypes TextWindowType
foreign import ccall "gtk_text_window_type_get_type" c_gtk_text_window_type_get_type ::
IO GType
instance B.Types.TypedObject TextWindowType where
glibType :: IO GType
glibType = IO GType
c_gtk_text_window_type_get_type
instance B.Types.BoxedEnum TextWindowType
data TextViewLayer =
TextViewLayerBelowText
| TextViewLayerAboveText
| AnotherTextViewLayer Int
deriving (Int -> TextViewLayer -> ShowS
[TextViewLayer] -> ShowS
TextViewLayer -> String
(Int -> TextViewLayer -> ShowS)
-> (TextViewLayer -> String)
-> ([TextViewLayer] -> ShowS)
-> Show TextViewLayer
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TextViewLayer] -> ShowS
$cshowList :: [TextViewLayer] -> ShowS
show :: TextViewLayer -> String
$cshow :: TextViewLayer -> String
showsPrec :: Int -> TextViewLayer -> ShowS
$cshowsPrec :: Int -> TextViewLayer -> ShowS
Show, TextViewLayer -> TextViewLayer -> Bool
(TextViewLayer -> TextViewLayer -> Bool)
-> (TextViewLayer -> TextViewLayer -> Bool) -> Eq TextViewLayer
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TextViewLayer -> TextViewLayer -> Bool
$c/= :: TextViewLayer -> TextViewLayer -> Bool
== :: TextViewLayer -> TextViewLayer -> Bool
$c== :: TextViewLayer -> TextViewLayer -> Bool
Eq)
instance P.Enum TextViewLayer where
fromEnum :: TextViewLayer -> Int
fromEnum TextViewLayer
TextViewLayerBelowText = Int
0
fromEnum TextViewLayer
TextViewLayerAboveText = Int
1
fromEnum (AnotherTextViewLayer Int
k) = Int
k
toEnum :: Int -> TextViewLayer
toEnum Int
0 = TextViewLayer
TextViewLayerBelowText
toEnum Int
1 = TextViewLayer
TextViewLayerAboveText
toEnum Int
k = Int -> TextViewLayer
AnotherTextViewLayer Int
k
instance P.Ord TextViewLayer where
compare :: TextViewLayer -> TextViewLayer -> Ordering
compare TextViewLayer
a TextViewLayer
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (TextViewLayer -> Int
forall a. Enum a => a -> Int
P.fromEnum TextViewLayer
a) (TextViewLayer -> Int
forall a. Enum a => a -> Int
P.fromEnum TextViewLayer
b)
type instance O.ParentTypes TextViewLayer = '[]
instance O.HasParentTypes TextViewLayer
foreign import ccall "gtk_text_view_layer_get_type" c_gtk_text_view_layer_get_type ::
IO GType
instance B.Types.TypedObject TextViewLayer where
glibType :: IO GType
glibType = IO GType
c_gtk_text_view_layer_get_type
instance B.Types.BoxedEnum TextViewLayer
data TextExtendSelection =
TextExtendSelectionWord
| TextExtendSelectionLine
| AnotherTextExtendSelection Int
deriving (Int -> TextExtendSelection -> ShowS
[TextExtendSelection] -> ShowS
TextExtendSelection -> String
(Int -> TextExtendSelection -> ShowS)
-> (TextExtendSelection -> String)
-> ([TextExtendSelection] -> ShowS)
-> Show TextExtendSelection
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TextExtendSelection] -> ShowS
$cshowList :: [TextExtendSelection] -> ShowS
show :: TextExtendSelection -> String
$cshow :: TextExtendSelection -> String
showsPrec :: Int -> TextExtendSelection -> ShowS
$cshowsPrec :: Int -> TextExtendSelection -> ShowS
Show, TextExtendSelection -> TextExtendSelection -> Bool
(TextExtendSelection -> TextExtendSelection -> Bool)
-> (TextExtendSelection -> TextExtendSelection -> Bool)
-> Eq TextExtendSelection
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TextExtendSelection -> TextExtendSelection -> Bool
$c/= :: TextExtendSelection -> TextExtendSelection -> Bool
== :: TextExtendSelection -> TextExtendSelection -> Bool
$c== :: TextExtendSelection -> TextExtendSelection -> Bool
Eq)
instance P.Enum TextExtendSelection where
fromEnum :: TextExtendSelection -> Int
fromEnum TextExtendSelection
TextExtendSelectionWord = Int
0
fromEnum TextExtendSelection
TextExtendSelectionLine = Int
1
fromEnum (AnotherTextExtendSelection Int
k) = Int
k
toEnum :: Int -> TextExtendSelection
toEnum Int
0 = TextExtendSelection
TextExtendSelectionWord
toEnum Int
1 = TextExtendSelection
TextExtendSelectionLine
toEnum Int
k = Int -> TextExtendSelection
AnotherTextExtendSelection Int
k
instance P.Ord TextExtendSelection where
compare :: TextExtendSelection -> TextExtendSelection -> Ordering
compare TextExtendSelection
a TextExtendSelection
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (TextExtendSelection -> Int
forall a. Enum a => a -> Int
P.fromEnum TextExtendSelection
a) (TextExtendSelection -> Int
forall a. Enum a => a -> Int
P.fromEnum TextExtendSelection
b)
type instance O.ParentTypes TextExtendSelection = '[]
instance O.HasParentTypes TextExtendSelection
foreign import ccall "gtk_text_extend_selection_get_type" c_gtk_text_extend_selection_get_type ::
IO GType
instance B.Types.TypedObject TextExtendSelection where
glibType :: IO GType
glibType = IO GType
c_gtk_text_extend_selection_get_type
instance B.Types.BoxedEnum TextExtendSelection
data TextDirection =
TextDirectionNone
| TextDirectionLtr
| TextDirectionRtl
| AnotherTextDirection Int
deriving (Int -> TextDirection -> ShowS
[TextDirection] -> ShowS
TextDirection -> String
(Int -> TextDirection -> ShowS)
-> (TextDirection -> String)
-> ([TextDirection] -> ShowS)
-> Show TextDirection
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TextDirection] -> ShowS
$cshowList :: [TextDirection] -> ShowS
show :: TextDirection -> String
$cshow :: TextDirection -> String
showsPrec :: Int -> TextDirection -> ShowS
$cshowsPrec :: Int -> TextDirection -> ShowS
Show, TextDirection -> TextDirection -> Bool
(TextDirection -> TextDirection -> Bool)
-> (TextDirection -> TextDirection -> Bool) -> Eq TextDirection
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TextDirection -> TextDirection -> Bool
$c/= :: TextDirection -> TextDirection -> Bool
== :: TextDirection -> TextDirection -> Bool
$c== :: TextDirection -> TextDirection -> Bool
Eq)
instance P.Enum TextDirection where
fromEnum :: TextDirection -> Int
fromEnum TextDirection
TextDirectionNone = Int
0
fromEnum TextDirection
TextDirectionLtr = Int
1
fromEnum TextDirection
TextDirectionRtl = Int
2
fromEnum (AnotherTextDirection Int
k) = Int
k
toEnum :: Int -> TextDirection
toEnum Int
0 = TextDirection
TextDirectionNone
toEnum Int
1 = TextDirection
TextDirectionLtr
toEnum Int
2 = TextDirection
TextDirectionRtl
toEnum Int
k = Int -> TextDirection
AnotherTextDirection Int
k
instance P.Ord TextDirection where
compare :: TextDirection -> TextDirection -> Ordering
compare TextDirection
a TextDirection
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (TextDirection -> Int
forall a. Enum a => a -> Int
P.fromEnum TextDirection
a) (TextDirection -> Int
forall a. Enum a => a -> Int
P.fromEnum TextDirection
b)
type instance O.ParentTypes TextDirection = '[]
instance O.HasParentTypes TextDirection
foreign import ccall "gtk_text_direction_get_type" c_gtk_text_direction_get_type ::
IO GType
instance B.Types.TypedObject TextDirection where
glibType :: IO GType
glibType = IO GType
c_gtk_text_direction_get_type
instance B.Types.BoxedEnum TextDirection
data SystemSetting =
SystemSettingDpi
| SystemSettingFontName
| SystemSettingFontConfig
| SystemSettingDisplay
| SystemSettingIconTheme
| AnotherSystemSetting Int
deriving (Int -> SystemSetting -> ShowS
[SystemSetting] -> ShowS
SystemSetting -> String
(Int -> SystemSetting -> ShowS)
-> (SystemSetting -> String)
-> ([SystemSetting] -> ShowS)
-> Show SystemSetting
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SystemSetting] -> ShowS
$cshowList :: [SystemSetting] -> ShowS
show :: SystemSetting -> String
$cshow :: SystemSetting -> String
showsPrec :: Int -> SystemSetting -> ShowS
$cshowsPrec :: Int -> SystemSetting -> ShowS
Show, SystemSetting -> SystemSetting -> Bool
(SystemSetting -> SystemSetting -> Bool)
-> (SystemSetting -> SystemSetting -> Bool) -> Eq SystemSetting
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SystemSetting -> SystemSetting -> Bool
$c/= :: SystemSetting -> SystemSetting -> Bool
== :: SystemSetting -> SystemSetting -> Bool
$c== :: SystemSetting -> SystemSetting -> Bool
Eq)
instance P.Enum SystemSetting where
fromEnum :: SystemSetting -> Int
fromEnum SystemSetting
SystemSettingDpi = Int
0
fromEnum SystemSetting
SystemSettingFontName = Int
1
fromEnum SystemSetting
SystemSettingFontConfig = Int
2
fromEnum SystemSetting
SystemSettingDisplay = Int
3
fromEnum SystemSetting
SystemSettingIconTheme = Int
4
fromEnum (AnotherSystemSetting Int
k) = Int
k
toEnum :: Int -> SystemSetting
toEnum Int
0 = SystemSetting
SystemSettingDpi
toEnum Int
1 = SystemSetting
SystemSettingFontName
toEnum Int
2 = SystemSetting
SystemSettingFontConfig
toEnum Int
3 = SystemSetting
SystemSettingDisplay
toEnum Int
4 = SystemSetting
SystemSettingIconTheme
toEnum Int
k = Int -> SystemSetting
AnotherSystemSetting Int
k
instance P.Ord SystemSetting where
compare :: SystemSetting -> SystemSetting -> Ordering
compare SystemSetting
a SystemSetting
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SystemSetting -> Int
forall a. Enum a => a -> Int
P.fromEnum SystemSetting
a) (SystemSetting -> Int
forall a. Enum a => a -> Int
P.fromEnum SystemSetting
b)
type instance O.ParentTypes SystemSetting = '[]
instance O.HasParentTypes SystemSetting
foreign import ccall "gtk_system_setting_get_type" c_gtk_system_setting_get_type ::
IO GType
instance B.Types.TypedObject SystemSetting where
glibType :: IO GType
glibType = IO GType
c_gtk_system_setting_get_type
instance B.Types.BoxedEnum SystemSetting
data StringFilterMatchMode =
StringFilterMatchModeExact
| StringFilterMatchModeSubstring
| StringFilterMatchModePrefix
| AnotherStringFilterMatchMode Int
deriving (Int -> StringFilterMatchMode -> ShowS
[StringFilterMatchMode] -> ShowS
StringFilterMatchMode -> String
(Int -> StringFilterMatchMode -> ShowS)
-> (StringFilterMatchMode -> String)
-> ([StringFilterMatchMode] -> ShowS)
-> Show StringFilterMatchMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StringFilterMatchMode] -> ShowS
$cshowList :: [StringFilterMatchMode] -> ShowS
show :: StringFilterMatchMode -> String
$cshow :: StringFilterMatchMode -> String
showsPrec :: Int -> StringFilterMatchMode -> ShowS
$cshowsPrec :: Int -> StringFilterMatchMode -> ShowS
Show, StringFilterMatchMode -> StringFilterMatchMode -> Bool
(StringFilterMatchMode -> StringFilterMatchMode -> Bool)
-> (StringFilterMatchMode -> StringFilterMatchMode -> Bool)
-> Eq StringFilterMatchMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StringFilterMatchMode -> StringFilterMatchMode -> Bool
$c/= :: StringFilterMatchMode -> StringFilterMatchMode -> Bool
== :: StringFilterMatchMode -> StringFilterMatchMode -> Bool
$c== :: StringFilterMatchMode -> StringFilterMatchMode -> Bool
Eq)
instance P.Enum StringFilterMatchMode where
fromEnum :: StringFilterMatchMode -> Int
fromEnum StringFilterMatchMode
StringFilterMatchModeExact = Int
0
fromEnum StringFilterMatchMode
StringFilterMatchModeSubstring = Int
1
fromEnum StringFilterMatchMode
StringFilterMatchModePrefix = Int
2
fromEnum (AnotherStringFilterMatchMode Int
k) = Int
k
toEnum :: Int -> StringFilterMatchMode
toEnum Int
0 = StringFilterMatchMode
StringFilterMatchModeExact
toEnum Int
1 = StringFilterMatchMode
StringFilterMatchModeSubstring
toEnum Int
2 = StringFilterMatchMode
StringFilterMatchModePrefix
toEnum Int
k = Int -> StringFilterMatchMode
AnotherStringFilterMatchMode Int
k
instance P.Ord StringFilterMatchMode where
compare :: StringFilterMatchMode -> StringFilterMatchMode -> Ordering
compare StringFilterMatchMode
a StringFilterMatchMode
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (StringFilterMatchMode -> Int
forall a. Enum a => a -> Int
P.fromEnum StringFilterMatchMode
a) (StringFilterMatchMode -> Int
forall a. Enum a => a -> Int
P.fromEnum StringFilterMatchMode
b)
type instance O.ParentTypes StringFilterMatchMode = '[]
instance O.HasParentTypes StringFilterMatchMode
foreign import ccall "gtk_string_filter_match_mode_get_type" c_gtk_string_filter_match_mode_get_type ::
IO GType
instance B.Types.TypedObject StringFilterMatchMode where
glibType :: IO GType
glibType = IO GType
c_gtk_string_filter_match_mode_get_type
instance B.Types.BoxedEnum StringFilterMatchMode
data StackTransitionType =
StackTransitionTypeNone
| StackTransitionTypeCrossfade
| StackTransitionTypeSlideRight
| StackTransitionTypeSlideLeft
| StackTransitionTypeSlideUp
| StackTransitionTypeSlideDown
| StackTransitionTypeSlideLeftRight
| StackTransitionTypeSlideUpDown
| StackTransitionTypeOverUp
| StackTransitionTypeOverDown
| StackTransitionTypeOverLeft
| StackTransitionTypeOverRight
| StackTransitionTypeUnderUp
| StackTransitionTypeUnderDown
| StackTransitionTypeUnderLeft
| StackTransitionTypeUnderRight
| StackTransitionTypeOverUpDown
| StackTransitionTypeOverDownUp
| StackTransitionTypeOverLeftRight
| StackTransitionTypeOverRightLeft
| StackTransitionTypeRotateLeft
| StackTransitionTypeRotateRight
| StackTransitionTypeRotateLeftRight
| AnotherStackTransitionType Int
deriving (Int -> StackTransitionType -> ShowS
[StackTransitionType] -> ShowS
StackTransitionType -> String
(Int -> StackTransitionType -> ShowS)
-> (StackTransitionType -> String)
-> ([StackTransitionType] -> ShowS)
-> Show StackTransitionType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StackTransitionType] -> ShowS
$cshowList :: [StackTransitionType] -> ShowS
show :: StackTransitionType -> String
$cshow :: StackTransitionType -> String
showsPrec :: Int -> StackTransitionType -> ShowS
$cshowsPrec :: Int -> StackTransitionType -> ShowS
Show, StackTransitionType -> StackTransitionType -> Bool
(StackTransitionType -> StackTransitionType -> Bool)
-> (StackTransitionType -> StackTransitionType -> Bool)
-> Eq StackTransitionType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StackTransitionType -> StackTransitionType -> Bool
$c/= :: StackTransitionType -> StackTransitionType -> Bool
== :: StackTransitionType -> StackTransitionType -> Bool
$c== :: StackTransitionType -> StackTransitionType -> Bool
Eq)
instance P.Enum StackTransitionType where
fromEnum :: StackTransitionType -> Int
fromEnum StackTransitionType
StackTransitionTypeNone = Int
0
fromEnum StackTransitionType
StackTransitionTypeCrossfade = Int
1
fromEnum StackTransitionType
StackTransitionTypeSlideRight = Int
2
fromEnum StackTransitionType
StackTransitionTypeSlideLeft = Int
3
fromEnum StackTransitionType
StackTransitionTypeSlideUp = Int
4
fromEnum StackTransitionType
StackTransitionTypeSlideDown = Int
5
fromEnum StackTransitionType
StackTransitionTypeSlideLeftRight = Int
6
fromEnum StackTransitionType
StackTransitionTypeSlideUpDown = Int
7
fromEnum StackTransitionType
StackTransitionTypeOverUp = Int
8
fromEnum StackTransitionType
StackTransitionTypeOverDown = Int
9
fromEnum StackTransitionType
StackTransitionTypeOverLeft = Int
10
fromEnum StackTransitionType
StackTransitionTypeOverRight = Int
11
fromEnum StackTransitionType
StackTransitionTypeUnderUp = Int
12
fromEnum StackTransitionType
StackTransitionTypeUnderDown = Int
13
fromEnum StackTransitionType
StackTransitionTypeUnderLeft = Int
14
fromEnum StackTransitionType
StackTransitionTypeUnderRight = Int
15
fromEnum StackTransitionType
StackTransitionTypeOverUpDown = Int
16
fromEnum StackTransitionType
StackTransitionTypeOverDownUp = Int
17
fromEnum StackTransitionType
StackTransitionTypeOverLeftRight = Int
18
fromEnum StackTransitionType
StackTransitionTypeOverRightLeft = Int
19
fromEnum StackTransitionType
StackTransitionTypeRotateLeft = Int
20
fromEnum StackTransitionType
StackTransitionTypeRotateRight = Int
21
fromEnum StackTransitionType
StackTransitionTypeRotateLeftRight = Int
22
fromEnum (AnotherStackTransitionType Int
k) = Int
k
toEnum :: Int -> StackTransitionType
toEnum Int
0 = StackTransitionType
StackTransitionTypeNone
toEnum Int
1 = StackTransitionType
StackTransitionTypeCrossfade
toEnum Int
2 = StackTransitionType
StackTransitionTypeSlideRight
toEnum Int
3 = StackTransitionType
StackTransitionTypeSlideLeft
toEnum Int
4 = StackTransitionType
StackTransitionTypeSlideUp
toEnum Int
5 = StackTransitionType
StackTransitionTypeSlideDown
toEnum Int
6 = StackTransitionType
StackTransitionTypeSlideLeftRight
toEnum Int
7 = StackTransitionType
StackTransitionTypeSlideUpDown
toEnum Int
8 = StackTransitionType
StackTransitionTypeOverUp
toEnum Int
9 = StackTransitionType
StackTransitionTypeOverDown
toEnum Int
10 = StackTransitionType
StackTransitionTypeOverLeft
toEnum Int
11 = StackTransitionType
StackTransitionTypeOverRight
toEnum Int
12 = StackTransitionType
StackTransitionTypeUnderUp
toEnum Int
13 = StackTransitionType
StackTransitionTypeUnderDown
toEnum Int
14 = StackTransitionType
StackTransitionTypeUnderLeft
toEnum Int
15 = StackTransitionType
StackTransitionTypeUnderRight
toEnum Int
16 = StackTransitionType
StackTransitionTypeOverUpDown
toEnum Int
17 = StackTransitionType
StackTransitionTypeOverDownUp
toEnum Int
18 = StackTransitionType
StackTransitionTypeOverLeftRight
toEnum Int
19 = StackTransitionType
StackTransitionTypeOverRightLeft
toEnum Int
20 = StackTransitionType
StackTransitionTypeRotateLeft
toEnum Int
21 = StackTransitionType
StackTransitionTypeRotateRight
toEnum Int
22 = StackTransitionType
StackTransitionTypeRotateLeftRight
toEnum Int
k = Int -> StackTransitionType
AnotherStackTransitionType Int
k
instance P.Ord StackTransitionType where
compare :: StackTransitionType -> StackTransitionType -> Ordering
compare StackTransitionType
a StackTransitionType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (StackTransitionType -> Int
forall a. Enum a => a -> Int
P.fromEnum StackTransitionType
a) (StackTransitionType -> Int
forall a. Enum a => a -> Int
P.fromEnum StackTransitionType
b)
type instance O.ParentTypes StackTransitionType = '[]
instance O.HasParentTypes StackTransitionType
foreign import ccall "gtk_stack_transition_type_get_type" c_gtk_stack_transition_type_get_type ::
IO GType
instance B.Types.TypedObject StackTransitionType where
glibType :: IO GType
glibType = IO GType
c_gtk_stack_transition_type_get_type
instance B.Types.BoxedEnum StackTransitionType
data SpinType =
SpinTypeStepForward
| SpinTypeStepBackward
| SpinTypePageForward
| SpinTypePageBackward
| SpinTypeHome
| SpinTypeEnd
| SpinTypeUserDefined
| AnotherSpinType Int
deriving (Int -> SpinType -> ShowS
[SpinType] -> ShowS
SpinType -> String
(Int -> SpinType -> ShowS)
-> (SpinType -> String) -> ([SpinType] -> ShowS) -> Show SpinType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SpinType] -> ShowS
$cshowList :: [SpinType] -> ShowS
show :: SpinType -> String
$cshow :: SpinType -> String
showsPrec :: Int -> SpinType -> ShowS
$cshowsPrec :: Int -> SpinType -> ShowS
Show, SpinType -> SpinType -> Bool
(SpinType -> SpinType -> Bool)
-> (SpinType -> SpinType -> Bool) -> Eq SpinType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SpinType -> SpinType -> Bool
$c/= :: SpinType -> SpinType -> Bool
== :: SpinType -> SpinType -> Bool
$c== :: SpinType -> SpinType -> Bool
Eq)
instance P.Enum SpinType where
fromEnum :: SpinType -> Int
fromEnum SpinType
SpinTypeStepForward = Int
0
fromEnum SpinType
SpinTypeStepBackward = Int
1
fromEnum SpinType
SpinTypePageForward = Int
2
fromEnum SpinType
SpinTypePageBackward = Int
3
fromEnum SpinType
SpinTypeHome = Int
4
fromEnum SpinType
SpinTypeEnd = Int
5
fromEnum SpinType
SpinTypeUserDefined = Int
6
fromEnum (AnotherSpinType Int
k) = Int
k
toEnum :: Int -> SpinType
toEnum Int
0 = SpinType
SpinTypeStepForward
toEnum Int
1 = SpinType
SpinTypeStepBackward
toEnum Int
2 = SpinType
SpinTypePageForward
toEnum Int
3 = SpinType
SpinTypePageBackward
toEnum Int
4 = SpinType
SpinTypeHome
toEnum Int
5 = SpinType
SpinTypeEnd
toEnum Int
6 = SpinType
SpinTypeUserDefined
toEnum Int
k = Int -> SpinType
AnotherSpinType Int
k
instance P.Ord SpinType where
compare :: SpinType -> SpinType -> Ordering
compare SpinType
a SpinType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SpinType -> Int
forall a. Enum a => a -> Int
P.fromEnum SpinType
a) (SpinType -> Int
forall a. Enum a => a -> Int
P.fromEnum SpinType
b)
type instance O.ParentTypes SpinType = '[]
instance O.HasParentTypes SpinType
foreign import ccall "gtk_spin_type_get_type" c_gtk_spin_type_get_type ::
IO GType
instance B.Types.TypedObject SpinType where
glibType :: IO GType
glibType = IO GType
c_gtk_spin_type_get_type
instance B.Types.BoxedEnum SpinType
data SpinButtonUpdatePolicy =
SpinButtonUpdatePolicyAlways
| SpinButtonUpdatePolicyIfValid
| AnotherSpinButtonUpdatePolicy Int
deriving (Int -> SpinButtonUpdatePolicy -> ShowS
[SpinButtonUpdatePolicy] -> ShowS
SpinButtonUpdatePolicy -> String
(Int -> SpinButtonUpdatePolicy -> ShowS)
-> (SpinButtonUpdatePolicy -> String)
-> ([SpinButtonUpdatePolicy] -> ShowS)
-> Show SpinButtonUpdatePolicy
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SpinButtonUpdatePolicy] -> ShowS
$cshowList :: [SpinButtonUpdatePolicy] -> ShowS
show :: SpinButtonUpdatePolicy -> String
$cshow :: SpinButtonUpdatePolicy -> String
showsPrec :: Int -> SpinButtonUpdatePolicy -> ShowS
$cshowsPrec :: Int -> SpinButtonUpdatePolicy -> ShowS
Show, SpinButtonUpdatePolicy -> SpinButtonUpdatePolicy -> Bool
(SpinButtonUpdatePolicy -> SpinButtonUpdatePolicy -> Bool)
-> (SpinButtonUpdatePolicy -> SpinButtonUpdatePolicy -> Bool)
-> Eq SpinButtonUpdatePolicy
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SpinButtonUpdatePolicy -> SpinButtonUpdatePolicy -> Bool
$c/= :: SpinButtonUpdatePolicy -> SpinButtonUpdatePolicy -> Bool
== :: SpinButtonUpdatePolicy -> SpinButtonUpdatePolicy -> Bool
$c== :: SpinButtonUpdatePolicy -> SpinButtonUpdatePolicy -> Bool
Eq)
instance P.Enum SpinButtonUpdatePolicy where
fromEnum :: SpinButtonUpdatePolicy -> Int
fromEnum SpinButtonUpdatePolicy
SpinButtonUpdatePolicyAlways = Int
0
fromEnum SpinButtonUpdatePolicy
SpinButtonUpdatePolicyIfValid = Int
1
fromEnum (AnotherSpinButtonUpdatePolicy Int
k) = Int
k
toEnum :: Int -> SpinButtonUpdatePolicy
toEnum Int
0 = SpinButtonUpdatePolicy
SpinButtonUpdatePolicyAlways
toEnum Int
1 = SpinButtonUpdatePolicy
SpinButtonUpdatePolicyIfValid
toEnum Int
k = Int -> SpinButtonUpdatePolicy
AnotherSpinButtonUpdatePolicy Int
k
instance P.Ord SpinButtonUpdatePolicy where
compare :: SpinButtonUpdatePolicy -> SpinButtonUpdatePolicy -> Ordering
compare SpinButtonUpdatePolicy
a SpinButtonUpdatePolicy
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SpinButtonUpdatePolicy -> Int
forall a. Enum a => a -> Int
P.fromEnum SpinButtonUpdatePolicy
a) (SpinButtonUpdatePolicy -> Int
forall a. Enum a => a -> Int
P.fromEnum SpinButtonUpdatePolicy
b)
type instance O.ParentTypes SpinButtonUpdatePolicy = '[]
instance O.HasParentTypes SpinButtonUpdatePolicy
foreign import ccall "gtk_spin_button_update_policy_get_type" c_gtk_spin_button_update_policy_get_type ::
IO GType
instance B.Types.TypedObject SpinButtonUpdatePolicy where
glibType :: IO GType
glibType = IO GType
c_gtk_spin_button_update_policy_get_type
instance B.Types.BoxedEnum SpinButtonUpdatePolicy
data SorterOrder =
SorterOrderPartial
| SorterOrderNone
| SorterOrderTotal
| AnotherSorterOrder Int
deriving (Int -> SorterOrder -> ShowS
[SorterOrder] -> ShowS
SorterOrder -> String
(Int -> SorterOrder -> ShowS)
-> (SorterOrder -> String)
-> ([SorterOrder] -> ShowS)
-> Show SorterOrder
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SorterOrder] -> ShowS
$cshowList :: [SorterOrder] -> ShowS
show :: SorterOrder -> String
$cshow :: SorterOrder -> String
showsPrec :: Int -> SorterOrder -> ShowS
$cshowsPrec :: Int -> SorterOrder -> ShowS
Show, SorterOrder -> SorterOrder -> Bool
(SorterOrder -> SorterOrder -> Bool)
-> (SorterOrder -> SorterOrder -> Bool) -> Eq SorterOrder
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SorterOrder -> SorterOrder -> Bool
$c/= :: SorterOrder -> SorterOrder -> Bool
== :: SorterOrder -> SorterOrder -> Bool
$c== :: SorterOrder -> SorterOrder -> Bool
Eq)
instance P.Enum SorterOrder where
fromEnum :: SorterOrder -> Int
fromEnum SorterOrder
SorterOrderPartial = Int
0
fromEnum SorterOrder
SorterOrderNone = Int
1
fromEnum SorterOrder
SorterOrderTotal = Int
2
fromEnum (AnotherSorterOrder Int
k) = Int
k
toEnum :: Int -> SorterOrder
toEnum Int
0 = SorterOrder
SorterOrderPartial
toEnum Int
1 = SorterOrder
SorterOrderNone
toEnum Int
2 = SorterOrder
SorterOrderTotal
toEnum Int
k = Int -> SorterOrder
AnotherSorterOrder Int
k
instance P.Ord SorterOrder where
compare :: SorterOrder -> SorterOrder -> Ordering
compare SorterOrder
a SorterOrder
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SorterOrder -> Int
forall a. Enum a => a -> Int
P.fromEnum SorterOrder
a) (SorterOrder -> Int
forall a. Enum a => a -> Int
P.fromEnum SorterOrder
b)
type instance O.ParentTypes SorterOrder = '[]
instance O.HasParentTypes SorterOrder
foreign import ccall "gtk_sorter_order_get_type" c_gtk_sorter_order_get_type ::
IO GType
instance B.Types.TypedObject SorterOrder where
glibType :: IO GType
glibType = IO GType
c_gtk_sorter_order_get_type
instance B.Types.BoxedEnum SorterOrder
data SorterChange =
SorterChangeDifferent
| SorterChangeInverted
| SorterChangeLessStrict
| SorterChangeMoreStrict
| AnotherSorterChange Int
deriving (Int -> SorterChange -> ShowS
[SorterChange] -> ShowS
SorterChange -> String
(Int -> SorterChange -> ShowS)
-> (SorterChange -> String)
-> ([SorterChange] -> ShowS)
-> Show SorterChange
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SorterChange] -> ShowS
$cshowList :: [SorterChange] -> ShowS
show :: SorterChange -> String
$cshow :: SorterChange -> String
showsPrec :: Int -> SorterChange -> ShowS
$cshowsPrec :: Int -> SorterChange -> ShowS
Show, SorterChange -> SorterChange -> Bool
(SorterChange -> SorterChange -> Bool)
-> (SorterChange -> SorterChange -> Bool) -> Eq SorterChange
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SorterChange -> SorterChange -> Bool
$c/= :: SorterChange -> SorterChange -> Bool
== :: SorterChange -> SorterChange -> Bool
$c== :: SorterChange -> SorterChange -> Bool
Eq)
instance P.Enum SorterChange where
fromEnum :: SorterChange -> Int
fromEnum SorterChange
SorterChangeDifferent = Int
0
fromEnum SorterChange
SorterChangeInverted = Int
1
fromEnum SorterChange
SorterChangeLessStrict = Int
2
fromEnum SorterChange
SorterChangeMoreStrict = Int
3
fromEnum (AnotherSorterChange Int
k) = Int
k
toEnum :: Int -> SorterChange
toEnum Int
0 = SorterChange
SorterChangeDifferent
toEnum Int
1 = SorterChange
SorterChangeInverted
toEnum Int
2 = SorterChange
SorterChangeLessStrict
toEnum Int
3 = SorterChange
SorterChangeMoreStrict
toEnum Int
k = Int -> SorterChange
AnotherSorterChange Int
k
instance P.Ord SorterChange where
compare :: SorterChange -> SorterChange -> Ordering
compare SorterChange
a SorterChange
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SorterChange -> Int
forall a. Enum a => a -> Int
P.fromEnum SorterChange
a) (SorterChange -> Int
forall a. Enum a => a -> Int
P.fromEnum SorterChange
b)
type instance O.ParentTypes SorterChange = '[]
instance O.HasParentTypes SorterChange
foreign import ccall "gtk_sorter_change_get_type" c_gtk_sorter_change_get_type ::
IO GType
instance B.Types.TypedObject SorterChange where
glibType :: IO GType
glibType = IO GType
c_gtk_sorter_change_get_type
instance B.Types.BoxedEnum SorterChange
data SortType =
SortTypeAscending
| SortTypeDescending
| AnotherSortType Int
deriving (Int -> SortType -> ShowS
[SortType] -> ShowS
SortType -> String
(Int -> SortType -> ShowS)
-> (SortType -> String) -> ([SortType] -> ShowS) -> Show SortType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SortType] -> ShowS
$cshowList :: [SortType] -> ShowS
show :: SortType -> String
$cshow :: SortType -> String
showsPrec :: Int -> SortType -> ShowS
$cshowsPrec :: Int -> SortType -> ShowS
Show, SortType -> SortType -> Bool
(SortType -> SortType -> Bool)
-> (SortType -> SortType -> Bool) -> Eq SortType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SortType -> SortType -> Bool
$c/= :: SortType -> SortType -> Bool
== :: SortType -> SortType -> Bool
$c== :: SortType -> SortType -> Bool
Eq)
instance P.Enum SortType where
fromEnum :: SortType -> Int
fromEnum SortType
SortTypeAscending = Int
0
fromEnum SortType
SortTypeDescending = Int
1
fromEnum (AnotherSortType Int
k) = Int
k
toEnum :: Int -> SortType
toEnum Int
0 = SortType
SortTypeAscending
toEnum Int
1 = SortType
SortTypeDescending
toEnum Int
k = Int -> SortType
AnotherSortType Int
k
instance P.Ord SortType where
compare :: SortType -> SortType -> Ordering
compare SortType
a SortType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SortType -> Int
forall a. Enum a => a -> Int
P.fromEnum SortType
a) (SortType -> Int
forall a. Enum a => a -> Int
P.fromEnum SortType
b)
type instance O.ParentTypes SortType = '[]
instance O.HasParentTypes SortType
foreign import ccall "gtk_sort_type_get_type" c_gtk_sort_type_get_type ::
IO GType
instance B.Types.TypedObject SortType where
glibType :: IO GType
glibType = IO GType
c_gtk_sort_type_get_type
instance B.Types.BoxedEnum SortType
data SizeRequestMode =
SizeRequestModeHeightForWidth
| SizeRequestModeWidthForHeight
| SizeRequestModeConstantSize
| AnotherSizeRequestMode Int
deriving (Int -> SizeRequestMode -> ShowS
[SizeRequestMode] -> ShowS
SizeRequestMode -> String
(Int -> SizeRequestMode -> ShowS)
-> (SizeRequestMode -> String)
-> ([SizeRequestMode] -> ShowS)
-> Show SizeRequestMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SizeRequestMode] -> ShowS
$cshowList :: [SizeRequestMode] -> ShowS
show :: SizeRequestMode -> String
$cshow :: SizeRequestMode -> String
showsPrec :: Int -> SizeRequestMode -> ShowS
$cshowsPrec :: Int -> SizeRequestMode -> ShowS
Show, SizeRequestMode -> SizeRequestMode -> Bool
(SizeRequestMode -> SizeRequestMode -> Bool)
-> (SizeRequestMode -> SizeRequestMode -> Bool)
-> Eq SizeRequestMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SizeRequestMode -> SizeRequestMode -> Bool
$c/= :: SizeRequestMode -> SizeRequestMode -> Bool
== :: SizeRequestMode -> SizeRequestMode -> Bool
$c== :: SizeRequestMode -> SizeRequestMode -> Bool
Eq)
instance P.Enum SizeRequestMode where
fromEnum :: SizeRequestMode -> Int
fromEnum SizeRequestMode
SizeRequestModeHeightForWidth = Int
0
fromEnum SizeRequestMode
SizeRequestModeWidthForHeight = Int
1
fromEnum SizeRequestMode
SizeRequestModeConstantSize = Int
2
fromEnum (AnotherSizeRequestMode Int
k) = Int
k
toEnum :: Int -> SizeRequestMode
toEnum Int
0 = SizeRequestMode
SizeRequestModeHeightForWidth
toEnum Int
1 = SizeRequestMode
SizeRequestModeWidthForHeight
toEnum Int
2 = SizeRequestMode
SizeRequestModeConstantSize
toEnum Int
k = Int -> SizeRequestMode
AnotherSizeRequestMode Int
k
instance P.Ord SizeRequestMode where
compare :: SizeRequestMode -> SizeRequestMode -> Ordering
compare SizeRequestMode
a SizeRequestMode
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SizeRequestMode -> Int
forall a. Enum a => a -> Int
P.fromEnum SizeRequestMode
a) (SizeRequestMode -> Int
forall a. Enum a => a -> Int
P.fromEnum SizeRequestMode
b)
type instance O.ParentTypes SizeRequestMode = '[]
instance O.HasParentTypes SizeRequestMode
foreign import ccall "gtk_size_request_mode_get_type" c_gtk_size_request_mode_get_type ::
IO GType
instance B.Types.TypedObject SizeRequestMode where
glibType :: IO GType
glibType = IO GType
c_gtk_size_request_mode_get_type
instance B.Types.BoxedEnum SizeRequestMode
data SizeGroupMode =
SizeGroupModeNone
| SizeGroupModeHorizontal
| SizeGroupModeVertical
| SizeGroupModeBoth
| AnotherSizeGroupMode Int
deriving (Int -> SizeGroupMode -> ShowS
[SizeGroupMode] -> ShowS
SizeGroupMode -> String
(Int -> SizeGroupMode -> ShowS)
-> (SizeGroupMode -> String)
-> ([SizeGroupMode] -> ShowS)
-> Show SizeGroupMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SizeGroupMode] -> ShowS
$cshowList :: [SizeGroupMode] -> ShowS
show :: SizeGroupMode -> String
$cshow :: SizeGroupMode -> String
showsPrec :: Int -> SizeGroupMode -> ShowS
$cshowsPrec :: Int -> SizeGroupMode -> ShowS
Show, SizeGroupMode -> SizeGroupMode -> Bool
(SizeGroupMode -> SizeGroupMode -> Bool)
-> (SizeGroupMode -> SizeGroupMode -> Bool) -> Eq SizeGroupMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SizeGroupMode -> SizeGroupMode -> Bool
$c/= :: SizeGroupMode -> SizeGroupMode -> Bool
== :: SizeGroupMode -> SizeGroupMode -> Bool
$c== :: SizeGroupMode -> SizeGroupMode -> Bool
Eq)
instance P.Enum SizeGroupMode where
fromEnum :: SizeGroupMode -> Int
fromEnum SizeGroupMode
SizeGroupModeNone = Int
0
fromEnum SizeGroupMode
SizeGroupModeHorizontal = Int
1
fromEnum SizeGroupMode
SizeGroupModeVertical = Int
2
fromEnum SizeGroupMode
SizeGroupModeBoth = Int
3
fromEnum (AnotherSizeGroupMode Int
k) = Int
k
toEnum :: Int -> SizeGroupMode
toEnum Int
0 = SizeGroupMode
SizeGroupModeNone
toEnum Int
1 = SizeGroupMode
SizeGroupModeHorizontal
toEnum Int
2 = SizeGroupMode
SizeGroupModeVertical
toEnum Int
3 = SizeGroupMode
SizeGroupModeBoth
toEnum Int
k = Int -> SizeGroupMode
AnotherSizeGroupMode Int
k
instance P.Ord SizeGroupMode where
compare :: SizeGroupMode -> SizeGroupMode -> Ordering
compare SizeGroupMode
a SizeGroupMode
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SizeGroupMode -> Int
forall a. Enum a => a -> Int
P.fromEnum SizeGroupMode
a) (SizeGroupMode -> Int
forall a. Enum a => a -> Int
P.fromEnum SizeGroupMode
b)
type instance O.ParentTypes SizeGroupMode = '[]
instance O.HasParentTypes SizeGroupMode
foreign import ccall "gtk_size_group_mode_get_type" c_gtk_size_group_mode_get_type ::
IO GType
instance B.Types.TypedObject SizeGroupMode where
glibType :: IO GType
glibType = IO GType
c_gtk_size_group_mode_get_type
instance B.Types.BoxedEnum SizeGroupMode
data ShortcutType =
ShortcutTypeAccelerator
| ShortcutTypeGesturePinch
| ShortcutTypeGestureStretch
| ShortcutTypeGestureRotateClockwise
| ShortcutTypeGestureRotateCounterclockwise
| ShortcutTypeGestureTwoFingerSwipeLeft
| ShortcutTypeGestureTwoFingerSwipeRight
| ShortcutTypeGesture
| ShortcutTypeGestureSwipeLeft
| ShortcutTypeGestureSwipeRight
| AnotherShortcutType Int
deriving (Int -> ShortcutType -> ShowS
[ShortcutType] -> ShowS
ShortcutType -> String
(Int -> ShortcutType -> ShowS)
-> (ShortcutType -> String)
-> ([ShortcutType] -> ShowS)
-> Show ShortcutType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ShortcutType] -> ShowS
$cshowList :: [ShortcutType] -> ShowS
show :: ShortcutType -> String
$cshow :: ShortcutType -> String
showsPrec :: Int -> ShortcutType -> ShowS
$cshowsPrec :: Int -> ShortcutType -> ShowS
Show, ShortcutType -> ShortcutType -> Bool
(ShortcutType -> ShortcutType -> Bool)
-> (ShortcutType -> ShortcutType -> Bool) -> Eq ShortcutType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ShortcutType -> ShortcutType -> Bool
$c/= :: ShortcutType -> ShortcutType -> Bool
== :: ShortcutType -> ShortcutType -> Bool
$c== :: ShortcutType -> ShortcutType -> Bool
Eq)
instance P.Enum ShortcutType where
fromEnum :: ShortcutType -> Int
fromEnum ShortcutType
ShortcutTypeAccelerator = Int
0
fromEnum ShortcutType
ShortcutTypeGesturePinch = Int
1
fromEnum ShortcutType
ShortcutTypeGestureStretch = Int
2
fromEnum ShortcutType
ShortcutTypeGestureRotateClockwise = Int
3
fromEnum ShortcutType
ShortcutTypeGestureRotateCounterclockwise = Int
4
fromEnum ShortcutType
ShortcutTypeGestureTwoFingerSwipeLeft = Int
5
fromEnum ShortcutType
ShortcutTypeGestureTwoFingerSwipeRight = Int
6
fromEnum ShortcutType
ShortcutTypeGesture = Int
7
fromEnum ShortcutType
ShortcutTypeGestureSwipeLeft = Int
8
fromEnum ShortcutType
ShortcutTypeGestureSwipeRight = Int
9
fromEnum (AnotherShortcutType Int
k) = Int
k
toEnum :: Int -> ShortcutType
toEnum Int
0 = ShortcutType
ShortcutTypeAccelerator
toEnum Int
1 = ShortcutType
ShortcutTypeGesturePinch
toEnum Int
2 = ShortcutType
ShortcutTypeGestureStretch
toEnum Int
3 = ShortcutType
ShortcutTypeGestureRotateClockwise
toEnum Int
4 = ShortcutType
ShortcutTypeGestureRotateCounterclockwise
toEnum Int
5 = ShortcutType
ShortcutTypeGestureTwoFingerSwipeLeft
toEnum Int
6 = ShortcutType
ShortcutTypeGestureTwoFingerSwipeRight
toEnum Int
7 = ShortcutType
ShortcutTypeGesture
toEnum Int
8 = ShortcutType
ShortcutTypeGestureSwipeLeft
toEnum Int
9 = ShortcutType
ShortcutTypeGestureSwipeRight
toEnum Int
k = Int -> ShortcutType
AnotherShortcutType Int
k
instance P.Ord ShortcutType where
compare :: ShortcutType -> ShortcutType -> Ordering
compare ShortcutType
a ShortcutType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ShortcutType -> Int
forall a. Enum a => a -> Int
P.fromEnum ShortcutType
a) (ShortcutType -> Int
forall a. Enum a => a -> Int
P.fromEnum ShortcutType
b)
type instance O.ParentTypes ShortcutType = '[]
instance O.HasParentTypes ShortcutType
foreign import ccall "gtk_shortcut_type_get_type" c_gtk_shortcut_type_get_type ::
IO GType
instance B.Types.TypedObject ShortcutType where
glibType :: IO GType
glibType = IO GType
c_gtk_shortcut_type_get_type
instance B.Types.BoxedEnum ShortcutType
data ShortcutScope =
ShortcutScopeLocal
| ShortcutScopeManaged
| ShortcutScopeGlobal
| AnotherShortcutScope Int
deriving (Int -> ShortcutScope -> ShowS
[ShortcutScope] -> ShowS
ShortcutScope -> String
(Int -> ShortcutScope -> ShowS)
-> (ShortcutScope -> String)
-> ([ShortcutScope] -> ShowS)
-> Show ShortcutScope
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ShortcutScope] -> ShowS
$cshowList :: [ShortcutScope] -> ShowS
show :: ShortcutScope -> String
$cshow :: ShortcutScope -> String
showsPrec :: Int -> ShortcutScope -> ShowS
$cshowsPrec :: Int -> ShortcutScope -> ShowS
Show, ShortcutScope -> ShortcutScope -> Bool
(ShortcutScope -> ShortcutScope -> Bool)
-> (ShortcutScope -> ShortcutScope -> Bool) -> Eq ShortcutScope
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ShortcutScope -> ShortcutScope -> Bool
$c/= :: ShortcutScope -> ShortcutScope -> Bool
== :: ShortcutScope -> ShortcutScope -> Bool
$c== :: ShortcutScope -> ShortcutScope -> Bool
Eq)
instance P.Enum ShortcutScope where
fromEnum :: ShortcutScope -> Int
fromEnum ShortcutScope
ShortcutScopeLocal = Int
0
fromEnum ShortcutScope
ShortcutScopeManaged = Int
1
fromEnum ShortcutScope
ShortcutScopeGlobal = Int
2
fromEnum (AnotherShortcutScope Int
k) = Int
k
toEnum :: Int -> ShortcutScope
toEnum Int
0 = ShortcutScope
ShortcutScopeLocal
toEnum Int
1 = ShortcutScope
ShortcutScopeManaged
toEnum Int
2 = ShortcutScope
ShortcutScopeGlobal
toEnum Int
k = Int -> ShortcutScope
AnotherShortcutScope Int
k
instance P.Ord ShortcutScope where
compare :: ShortcutScope -> ShortcutScope -> Ordering
compare ShortcutScope
a ShortcutScope
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ShortcutScope -> Int
forall a. Enum a => a -> Int
P.fromEnum ShortcutScope
a) (ShortcutScope -> Int
forall a. Enum a => a -> Int
P.fromEnum ShortcutScope
b)
type instance O.ParentTypes ShortcutScope = '[]
instance O.HasParentTypes ShortcutScope
foreign import ccall "gtk_shortcut_scope_get_type" c_gtk_shortcut_scope_get_type ::
IO GType
instance B.Types.TypedObject ShortcutScope where
glibType :: IO GType
glibType = IO GType
c_gtk_shortcut_scope_get_type
instance B.Types.BoxedEnum ShortcutScope
data SensitivityType =
SensitivityTypeAuto
| SensitivityTypeOn
| SensitivityTypeOff
| AnotherSensitivityType Int
deriving (Int -> SensitivityType -> ShowS
[SensitivityType] -> ShowS
SensitivityType -> String
(Int -> SensitivityType -> ShowS)
-> (SensitivityType -> String)
-> ([SensitivityType] -> ShowS)
-> Show SensitivityType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SensitivityType] -> ShowS
$cshowList :: [SensitivityType] -> ShowS
show :: SensitivityType -> String
$cshow :: SensitivityType -> String
showsPrec :: Int -> SensitivityType -> ShowS
$cshowsPrec :: Int -> SensitivityType -> ShowS
Show, SensitivityType -> SensitivityType -> Bool
(SensitivityType -> SensitivityType -> Bool)
-> (SensitivityType -> SensitivityType -> Bool)
-> Eq SensitivityType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SensitivityType -> SensitivityType -> Bool
$c/= :: SensitivityType -> SensitivityType -> Bool
== :: SensitivityType -> SensitivityType -> Bool
$c== :: SensitivityType -> SensitivityType -> Bool
Eq)
instance P.Enum SensitivityType where
fromEnum :: SensitivityType -> Int
fromEnum SensitivityType
SensitivityTypeAuto = Int
0
fromEnum SensitivityType
SensitivityTypeOn = Int
1
fromEnum SensitivityType
SensitivityTypeOff = Int
2
fromEnum (AnotherSensitivityType Int
k) = Int
k
toEnum :: Int -> SensitivityType
toEnum Int
0 = SensitivityType
SensitivityTypeAuto
toEnum Int
1 = SensitivityType
SensitivityTypeOn
toEnum Int
2 = SensitivityType
SensitivityTypeOff
toEnum Int
k = Int -> SensitivityType
AnotherSensitivityType Int
k
instance P.Ord SensitivityType where
compare :: SensitivityType -> SensitivityType -> Ordering
compare SensitivityType
a SensitivityType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SensitivityType -> Int
forall a. Enum a => a -> Int
P.fromEnum SensitivityType
a) (SensitivityType -> Int
forall a. Enum a => a -> Int
P.fromEnum SensitivityType
b)
type instance O.ParentTypes SensitivityType = '[]
instance O.HasParentTypes SensitivityType
foreign import ccall "gtk_sensitivity_type_get_type" c_gtk_sensitivity_type_get_type ::
IO GType
instance B.Types.TypedObject SensitivityType where
glibType :: IO GType
glibType = IO GType
c_gtk_sensitivity_type_get_type
instance B.Types.BoxedEnum SensitivityType
data SelectionMode =
SelectionModeNone
| SelectionModeSingle
| SelectionModeBrowse
| SelectionModeMultiple
| AnotherSelectionMode Int
deriving (Int -> SelectionMode -> ShowS
[SelectionMode] -> ShowS
SelectionMode -> String
(Int -> SelectionMode -> ShowS)
-> (SelectionMode -> String)
-> ([SelectionMode] -> ShowS)
-> Show SelectionMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SelectionMode] -> ShowS
$cshowList :: [SelectionMode] -> ShowS
show :: SelectionMode -> String
$cshow :: SelectionMode -> String
showsPrec :: Int -> SelectionMode -> ShowS
$cshowsPrec :: Int -> SelectionMode -> ShowS
Show, SelectionMode -> SelectionMode -> Bool
(SelectionMode -> SelectionMode -> Bool)
-> (SelectionMode -> SelectionMode -> Bool) -> Eq SelectionMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SelectionMode -> SelectionMode -> Bool
$c/= :: SelectionMode -> SelectionMode -> Bool
== :: SelectionMode -> SelectionMode -> Bool
$c== :: SelectionMode -> SelectionMode -> Bool
Eq)
instance P.Enum SelectionMode where
fromEnum :: SelectionMode -> Int
fromEnum SelectionMode
SelectionModeNone = Int
0
fromEnum SelectionMode
SelectionModeSingle = Int
1
fromEnum SelectionMode
SelectionModeBrowse = Int
2
fromEnum SelectionMode
SelectionModeMultiple = Int
3
fromEnum (AnotherSelectionMode Int
k) = Int
k
toEnum :: Int -> SelectionMode
toEnum Int
0 = SelectionMode
SelectionModeNone
toEnum Int
1 = SelectionMode
SelectionModeSingle
toEnum Int
2 = SelectionMode
SelectionModeBrowse
toEnum Int
3 = SelectionMode
SelectionModeMultiple
toEnum Int
k = Int -> SelectionMode
AnotherSelectionMode Int
k
instance P.Ord SelectionMode where
compare :: SelectionMode -> SelectionMode -> Ordering
compare SelectionMode
a SelectionMode
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SelectionMode -> Int
forall a. Enum a => a -> Int
P.fromEnum SelectionMode
a) (SelectionMode -> Int
forall a. Enum a => a -> Int
P.fromEnum SelectionMode
b)
type instance O.ParentTypes SelectionMode = '[]
instance O.HasParentTypes SelectionMode
foreign import ccall "gtk_selection_mode_get_type" c_gtk_selection_mode_get_type ::
IO GType
instance B.Types.TypedObject SelectionMode where
glibType :: IO GType
glibType = IO GType
c_gtk_selection_mode_get_type
instance B.Types.BoxedEnum SelectionMode
data ScrollablePolicy =
ScrollablePolicyMinimum
| ScrollablePolicyNatural
| AnotherScrollablePolicy Int
deriving (Int -> ScrollablePolicy -> ShowS
[ScrollablePolicy] -> ShowS
ScrollablePolicy -> String
(Int -> ScrollablePolicy -> ShowS)
-> (ScrollablePolicy -> String)
-> ([ScrollablePolicy] -> ShowS)
-> Show ScrollablePolicy
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ScrollablePolicy] -> ShowS
$cshowList :: [ScrollablePolicy] -> ShowS
show :: ScrollablePolicy -> String
$cshow :: ScrollablePolicy -> String
showsPrec :: Int -> ScrollablePolicy -> ShowS
$cshowsPrec :: Int -> ScrollablePolicy -> ShowS
Show, ScrollablePolicy -> ScrollablePolicy -> Bool
(ScrollablePolicy -> ScrollablePolicy -> Bool)
-> (ScrollablePolicy -> ScrollablePolicy -> Bool)
-> Eq ScrollablePolicy
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ScrollablePolicy -> ScrollablePolicy -> Bool
$c/= :: ScrollablePolicy -> ScrollablePolicy -> Bool
== :: ScrollablePolicy -> ScrollablePolicy -> Bool
$c== :: ScrollablePolicy -> ScrollablePolicy -> Bool
Eq)
instance P.Enum ScrollablePolicy where
fromEnum :: ScrollablePolicy -> Int
fromEnum ScrollablePolicy
ScrollablePolicyMinimum = Int
0
fromEnum ScrollablePolicy
ScrollablePolicyNatural = Int
1
fromEnum (AnotherScrollablePolicy Int
k) = Int
k
toEnum :: Int -> ScrollablePolicy
toEnum Int
0 = ScrollablePolicy
ScrollablePolicyMinimum
toEnum Int
1 = ScrollablePolicy
ScrollablePolicyNatural
toEnum Int
k = Int -> ScrollablePolicy
AnotherScrollablePolicy Int
k
instance P.Ord ScrollablePolicy where
compare :: ScrollablePolicy -> ScrollablePolicy -> Ordering
compare ScrollablePolicy
a ScrollablePolicy
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ScrollablePolicy -> Int
forall a. Enum a => a -> Int
P.fromEnum ScrollablePolicy
a) (ScrollablePolicy -> Int
forall a. Enum a => a -> Int
P.fromEnum ScrollablePolicy
b)
type instance O.ParentTypes ScrollablePolicy = '[]
instance O.HasParentTypes ScrollablePolicy
foreign import ccall "gtk_scrollable_policy_get_type" c_gtk_scrollable_policy_get_type ::
IO GType
instance B.Types.TypedObject ScrollablePolicy where
glibType :: IO GType
glibType = IO GType
c_gtk_scrollable_policy_get_type
instance B.Types.BoxedEnum ScrollablePolicy
data ScrollType =
ScrollTypeNone
| ScrollTypeJump
| ScrollTypeStepBackward
| ScrollTypeStepForward
| ScrollTypePageBackward
| ScrollTypePageForward
| ScrollTypeStepUp
| ScrollTypeStepDown
| ScrollTypePageUp
| ScrollTypePageDown
| ScrollTypeStepLeft
| ScrollTypeStepRight
| ScrollTypePageLeft
|
| ScrollTypeStart
| ScrollTypeEnd
| AnotherScrollType Int
deriving (Int -> ScrollType -> ShowS
[ScrollType] -> ShowS
ScrollType -> String
(Int -> ScrollType -> ShowS)
-> (ScrollType -> String)
-> ([ScrollType] -> ShowS)
-> Show ScrollType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ScrollType] -> ShowS
$cshowList :: [ScrollType] -> ShowS
show :: ScrollType -> String
$cshow :: ScrollType -> String
showsPrec :: Int -> ScrollType -> ShowS
$cshowsPrec :: Int -> ScrollType -> ShowS
Show, ScrollType -> ScrollType -> Bool
(ScrollType -> ScrollType -> Bool)
-> (ScrollType -> ScrollType -> Bool) -> Eq ScrollType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ScrollType -> ScrollType -> Bool
$c/= :: ScrollType -> ScrollType -> Bool
== :: ScrollType -> ScrollType -> Bool
$c== :: ScrollType -> ScrollType -> Bool
Eq)
instance P.Enum ScrollType where
fromEnum :: ScrollType -> Int
fromEnum ScrollType
ScrollTypeNone = Int
0
fromEnum ScrollType
ScrollTypeJump = Int
1
fromEnum ScrollType
ScrollTypeStepBackward = Int
2
fromEnum ScrollType
ScrollTypeStepForward = Int
3
fromEnum ScrollType
ScrollTypePageBackward = Int
4
fromEnum ScrollType
ScrollTypePageForward = Int
5
fromEnum ScrollType
ScrollTypeStepUp = Int
6
fromEnum ScrollType
ScrollTypeStepDown = Int
7
fromEnum ScrollType
ScrollTypePageUp = Int
8
fromEnum ScrollType
ScrollTypePageDown = Int
9
fromEnum ScrollType
ScrollTypeStepLeft = Int
10
fromEnum ScrollType
ScrollTypeStepRight = Int
11
fromEnum ScrollType
ScrollTypePageLeft = Int
12
fromEnum ScrollType
ScrollTypePageRight = Int
13
fromEnum ScrollType
ScrollTypeStart = Int
14
fromEnum ScrollType
ScrollTypeEnd = Int
15
fromEnum (AnotherScrollType Int
k) = Int
k
toEnum :: Int -> ScrollType
toEnum Int
0 = ScrollType
ScrollTypeNone
toEnum Int
1 = ScrollType
ScrollTypeJump
toEnum Int
2 = ScrollType
ScrollTypeStepBackward
toEnum Int
3 = ScrollType
ScrollTypeStepForward
toEnum Int
4 = ScrollType
ScrollTypePageBackward
toEnum Int
5 = ScrollType
ScrollTypePageForward
toEnum Int
6 = ScrollType
ScrollTypeStepUp
toEnum Int
7 = ScrollType
ScrollTypeStepDown
toEnum Int
8 = ScrollType
ScrollTypePageUp
toEnum Int
9 = ScrollType
ScrollTypePageDown
toEnum Int
10 = ScrollType
ScrollTypeStepLeft
toEnum Int
11 = ScrollType
ScrollTypeStepRight
toEnum Int
12 = ScrollType
ScrollTypePageLeft
toEnum Int
13 = ScrollType
ScrollTypePageRight
toEnum Int
14 = ScrollType
ScrollTypeStart
toEnum Int
15 = ScrollType
ScrollTypeEnd
toEnum Int
k = Int -> ScrollType
AnotherScrollType Int
k
instance P.Ord ScrollType where
compare :: ScrollType -> ScrollType -> Ordering
compare ScrollType
a ScrollType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ScrollType -> Int
forall a. Enum a => a -> Int
P.fromEnum ScrollType
a) (ScrollType -> Int
forall a. Enum a => a -> Int
P.fromEnum ScrollType
b)
type instance O.ParentTypes ScrollType = '[]
instance O.HasParentTypes ScrollType
foreign import ccall "gtk_scroll_type_get_type" c_gtk_scroll_type_get_type ::
IO GType
instance B.Types.TypedObject ScrollType where
glibType :: IO GType
glibType = IO GType
c_gtk_scroll_type_get_type
instance B.Types.BoxedEnum ScrollType
data ScrollStep =
ScrollStepSteps
| ScrollStepPages
| ScrollStepEnds
| ScrollStepHorizontalSteps
| ScrollStepHorizontalPages
| ScrollStepHorizontalEnds
| AnotherScrollStep Int
deriving (Int -> ScrollStep -> ShowS
[ScrollStep] -> ShowS
ScrollStep -> String
(Int -> ScrollStep -> ShowS)
-> (ScrollStep -> String)
-> ([ScrollStep] -> ShowS)
-> Show ScrollStep
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ScrollStep] -> ShowS
$cshowList :: [ScrollStep] -> ShowS
show :: ScrollStep -> String
$cshow :: ScrollStep -> String
showsPrec :: Int -> ScrollStep -> ShowS
$cshowsPrec :: Int -> ScrollStep -> ShowS
Show, ScrollStep -> ScrollStep -> Bool
(ScrollStep -> ScrollStep -> Bool)
-> (ScrollStep -> ScrollStep -> Bool) -> Eq ScrollStep
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ScrollStep -> ScrollStep -> Bool
$c/= :: ScrollStep -> ScrollStep -> Bool
== :: ScrollStep -> ScrollStep -> Bool
$c== :: ScrollStep -> ScrollStep -> Bool
Eq)
instance P.Enum ScrollStep where
fromEnum :: ScrollStep -> Int
fromEnum ScrollStep
ScrollStepSteps = Int
0
fromEnum ScrollStep
ScrollStepPages = Int
1
fromEnum ScrollStep
ScrollStepEnds = Int
2
fromEnum ScrollStep
ScrollStepHorizontalSteps = Int
3
fromEnum ScrollStep
ScrollStepHorizontalPages = Int
4
fromEnum ScrollStep
ScrollStepHorizontalEnds = Int
5
fromEnum (AnotherScrollStep Int
k) = Int
k
toEnum :: Int -> ScrollStep
toEnum Int
0 = ScrollStep
ScrollStepSteps
toEnum Int
1 = ScrollStep
ScrollStepPages
toEnum Int
2 = ScrollStep
ScrollStepEnds
toEnum Int
3 = ScrollStep
ScrollStepHorizontalSteps
toEnum Int
4 = ScrollStep
ScrollStepHorizontalPages
toEnum Int
5 = ScrollStep
ScrollStepHorizontalEnds
toEnum Int
k = Int -> ScrollStep
AnotherScrollStep Int
k
instance P.Ord ScrollStep where
compare :: ScrollStep -> ScrollStep -> Ordering
compare ScrollStep
a ScrollStep
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ScrollStep -> Int
forall a. Enum a => a -> Int
P.fromEnum ScrollStep
a) (ScrollStep -> Int
forall a. Enum a => a -> Int
P.fromEnum ScrollStep
b)
type instance O.ParentTypes ScrollStep = '[]
instance O.HasParentTypes ScrollStep
foreign import ccall "gtk_scroll_step_get_type" c_gtk_scroll_step_get_type ::
IO GType
instance B.Types.TypedObject ScrollStep where
glibType :: IO GType
glibType = IO GType
c_gtk_scroll_step_get_type
instance B.Types.BoxedEnum ScrollStep
data RevealerTransitionType =
RevealerTransitionTypeNone
| RevealerTransitionTypeCrossfade
| RevealerTransitionTypeSlideRight
| RevealerTransitionTypeSlideLeft
| RevealerTransitionTypeSlideUp
| RevealerTransitionTypeSlideDown
| RevealerTransitionTypeSwingRight
| RevealerTransitionTypeSwingLeft
| RevealerTransitionTypeSwingUp
| RevealerTransitionTypeSwingDown
| AnotherRevealerTransitionType Int
deriving (Int -> RevealerTransitionType -> ShowS
[RevealerTransitionType] -> ShowS
RevealerTransitionType -> String
(Int -> RevealerTransitionType -> ShowS)
-> (RevealerTransitionType -> String)
-> ([RevealerTransitionType] -> ShowS)
-> Show RevealerTransitionType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RevealerTransitionType] -> ShowS
$cshowList :: [RevealerTransitionType] -> ShowS
show :: RevealerTransitionType -> String
$cshow :: RevealerTransitionType -> String
showsPrec :: Int -> RevealerTransitionType -> ShowS
$cshowsPrec :: Int -> RevealerTransitionType -> ShowS
Show, RevealerTransitionType -> RevealerTransitionType -> Bool
(RevealerTransitionType -> RevealerTransitionType -> Bool)
-> (RevealerTransitionType -> RevealerTransitionType -> Bool)
-> Eq RevealerTransitionType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RevealerTransitionType -> RevealerTransitionType -> Bool
$c/= :: RevealerTransitionType -> RevealerTransitionType -> Bool
== :: RevealerTransitionType -> RevealerTransitionType -> Bool
$c== :: RevealerTransitionType -> RevealerTransitionType -> Bool
Eq)
instance P.Enum RevealerTransitionType where
fromEnum :: RevealerTransitionType -> Int
fromEnum RevealerTransitionType
RevealerTransitionTypeNone = Int
0
fromEnum RevealerTransitionType
RevealerTransitionTypeCrossfade = Int
1
fromEnum RevealerTransitionType
RevealerTransitionTypeSlideRight = Int
2
fromEnum RevealerTransitionType
RevealerTransitionTypeSlideLeft = Int
3
fromEnum RevealerTransitionType
RevealerTransitionTypeSlideUp = Int
4
fromEnum RevealerTransitionType
RevealerTransitionTypeSlideDown = Int
5
fromEnum RevealerTransitionType
RevealerTransitionTypeSwingRight = Int
6
fromEnum RevealerTransitionType
RevealerTransitionTypeSwingLeft = Int
7
fromEnum RevealerTransitionType
RevealerTransitionTypeSwingUp = Int
8
fromEnum RevealerTransitionType
RevealerTransitionTypeSwingDown = Int
9
fromEnum (AnotherRevealerTransitionType Int
k) = Int
k
toEnum :: Int -> RevealerTransitionType
toEnum Int
0 = RevealerTransitionType
RevealerTransitionTypeNone
toEnum Int
1 = RevealerTransitionType
RevealerTransitionTypeCrossfade
toEnum Int
2 = RevealerTransitionType
RevealerTransitionTypeSlideRight
toEnum Int
3 = RevealerTransitionType
RevealerTransitionTypeSlideLeft
toEnum Int
4 = RevealerTransitionType
RevealerTransitionTypeSlideUp
toEnum Int
5 = RevealerTransitionType
RevealerTransitionTypeSlideDown
toEnum Int
6 = RevealerTransitionType
RevealerTransitionTypeSwingRight
toEnum Int
7 = RevealerTransitionType
RevealerTransitionTypeSwingLeft
toEnum Int
8 = RevealerTransitionType
RevealerTransitionTypeSwingUp
toEnum Int
9 = RevealerTransitionType
RevealerTransitionTypeSwingDown
toEnum Int
k = Int -> RevealerTransitionType
AnotherRevealerTransitionType Int
k
instance P.Ord RevealerTransitionType where
compare :: RevealerTransitionType -> RevealerTransitionType -> Ordering
compare RevealerTransitionType
a RevealerTransitionType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (RevealerTransitionType -> Int
forall a. Enum a => a -> Int
P.fromEnum RevealerTransitionType
a) (RevealerTransitionType -> Int
forall a. Enum a => a -> Int
P.fromEnum RevealerTransitionType
b)
type instance O.ParentTypes RevealerTransitionType = '[]
instance O.HasParentTypes RevealerTransitionType
foreign import ccall "gtk_revealer_transition_type_get_type" c_gtk_revealer_transition_type_get_type ::
IO GType
instance B.Types.TypedObject RevealerTransitionType where
glibType :: IO GType
glibType = IO GType
c_gtk_revealer_transition_type_get_type
instance B.Types.BoxedEnum RevealerTransitionType
data ResponseType =
ResponseTypeNone
| ResponseTypeReject
| ResponseTypeAccept
| ResponseTypeDeleteEvent
| ResponseTypeOk
| ResponseTypeCancel
| ResponseTypeClose
| ResponseTypeYes
| ResponseTypeNo
| ResponseTypeApply
| ResponseTypeHelp
| AnotherResponseType Int
deriving (Int -> ResponseType -> ShowS
[ResponseType] -> ShowS
ResponseType -> String
(Int -> ResponseType -> ShowS)
-> (ResponseType -> String)
-> ([ResponseType] -> ShowS)
-> Show ResponseType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ResponseType] -> ShowS
$cshowList :: [ResponseType] -> ShowS
show :: ResponseType -> String
$cshow :: ResponseType -> String
showsPrec :: Int -> ResponseType -> ShowS
$cshowsPrec :: Int -> ResponseType -> ShowS
Show, ResponseType -> ResponseType -> Bool
(ResponseType -> ResponseType -> Bool)
-> (ResponseType -> ResponseType -> Bool) -> Eq ResponseType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ResponseType -> ResponseType -> Bool
$c/= :: ResponseType -> ResponseType -> Bool
== :: ResponseType -> ResponseType -> Bool
$c== :: ResponseType -> ResponseType -> Bool
Eq)
instance P.Enum ResponseType where
fromEnum :: ResponseType -> Int
fromEnum ResponseType
ResponseTypeNone = Int
-1
fromEnum ResponseType
ResponseTypeReject = Int
-2
fromEnum ResponseType
ResponseTypeAccept = Int
-3
fromEnum ResponseType
ResponseTypeDeleteEvent = Int
-4
fromEnum ResponseType
ResponseTypeOk = Int
-5
fromEnum ResponseType
ResponseTypeCancel = Int
-6
fromEnum ResponseType
ResponseTypeClose = Int
-7
fromEnum ResponseType
ResponseTypeYes = Int
-8
fromEnum ResponseType
ResponseTypeNo = Int
-9
fromEnum ResponseType
ResponseTypeApply = Int
-10
fromEnum ResponseType
ResponseTypeHelp = Int
-11
fromEnum (AnotherResponseType Int
k) = Int
k
toEnum :: Int -> ResponseType
toEnum Int
-1 = ResponseType
ResponseTypeNone
toEnum Int
-2 = ResponseType
ResponseTypeReject
toEnum Int
-3 = ResponseType
ResponseTypeAccept
toEnum Int
-4 = ResponseType
ResponseTypeDeleteEvent
toEnum Int
-5 = ResponseType
ResponseTypeOk
toEnum Int
-6 = ResponseType
ResponseTypeCancel
toEnum Int
-7 = ResponseType
ResponseTypeClose
toEnum Int
-8 = ResponseType
ResponseTypeYes
toEnum Int
-9 = ResponseType
ResponseTypeNo
toEnum Int
-10 = ResponseType
ResponseTypeApply
toEnum Int
-11 = ResponseType
ResponseTypeHelp
toEnum Int
k = Int -> ResponseType
AnotherResponseType Int
k
instance P.Ord ResponseType where
compare :: ResponseType -> ResponseType -> Ordering
compare ResponseType
a ResponseType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ResponseType -> Int
forall a. Enum a => a -> Int
P.fromEnum ResponseType
a) (ResponseType -> Int
forall a. Enum a => a -> Int
P.fromEnum ResponseType
b)
type instance O.ParentTypes ResponseType = '[]
instance O.HasParentTypes ResponseType
foreign import ccall "gtk_response_type_get_type" c_gtk_response_type_get_type ::
IO GType
instance B.Types.TypedObject ResponseType where
glibType :: IO GType
glibType = IO GType
c_gtk_response_type_get_type
instance B.Types.BoxedEnum ResponseType
data RecentManagerError =
RecentManagerErrorNotFound
| RecentManagerErrorInvalidUri
| RecentManagerErrorInvalidEncoding
| RecentManagerErrorNotRegistered
| RecentManagerErrorRead
| RecentManagerErrorWrite
| RecentManagerErrorUnknown
| AnotherRecentManagerError Int
deriving (Int -> RecentManagerError -> ShowS
[RecentManagerError] -> ShowS
RecentManagerError -> String
(Int -> RecentManagerError -> ShowS)
-> (RecentManagerError -> String)
-> ([RecentManagerError] -> ShowS)
-> Show RecentManagerError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RecentManagerError] -> ShowS
$cshowList :: [RecentManagerError] -> ShowS
show :: RecentManagerError -> String
$cshow :: RecentManagerError -> String
showsPrec :: Int -> RecentManagerError -> ShowS
$cshowsPrec :: Int -> RecentManagerError -> ShowS
Show, RecentManagerError -> RecentManagerError -> Bool
(RecentManagerError -> RecentManagerError -> Bool)
-> (RecentManagerError -> RecentManagerError -> Bool)
-> Eq RecentManagerError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RecentManagerError -> RecentManagerError -> Bool
$c/= :: RecentManagerError -> RecentManagerError -> Bool
== :: RecentManagerError -> RecentManagerError -> Bool
$c== :: RecentManagerError -> RecentManagerError -> Bool
Eq)
instance P.Enum RecentManagerError where
fromEnum :: RecentManagerError -> Int
fromEnum RecentManagerError
RecentManagerErrorNotFound = Int
0
fromEnum RecentManagerError
RecentManagerErrorInvalidUri = Int
1
fromEnum RecentManagerError
RecentManagerErrorInvalidEncoding = Int
2
fromEnum RecentManagerError
RecentManagerErrorNotRegistered = Int
3
fromEnum RecentManagerError
RecentManagerErrorRead = Int
4
fromEnum RecentManagerError
RecentManagerErrorWrite = Int
5
fromEnum RecentManagerError
RecentManagerErrorUnknown = Int
6
fromEnum (AnotherRecentManagerError Int
k) = Int
k
toEnum :: Int -> RecentManagerError
toEnum Int
0 = RecentManagerError
RecentManagerErrorNotFound
toEnum Int
1 = RecentManagerError
RecentManagerErrorInvalidUri
toEnum Int
2 = RecentManagerError
RecentManagerErrorInvalidEncoding
toEnum Int
3 = RecentManagerError
RecentManagerErrorNotRegistered
toEnum Int
4 = RecentManagerError
RecentManagerErrorRead
toEnum Int
5 = RecentManagerError
RecentManagerErrorWrite
toEnum Int
6 = RecentManagerError
RecentManagerErrorUnknown
toEnum Int
k = Int -> RecentManagerError
AnotherRecentManagerError Int
k
instance P.Ord RecentManagerError where
compare :: RecentManagerError -> RecentManagerError -> Ordering
compare RecentManagerError
a RecentManagerError
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (RecentManagerError -> Int
forall a. Enum a => a -> Int
P.fromEnum RecentManagerError
a) (RecentManagerError -> Int
forall a. Enum a => a -> Int
P.fromEnum RecentManagerError
b)
instance GErrorClass RecentManagerError where
gerrorClassDomain :: RecentManagerError -> Text
gerrorClassDomain RecentManagerError
_ = Text
"gtk-recent-manager-error-quark"
catchRecentManagerError ::
IO a ->
(RecentManagerError -> GErrorMessage -> IO a) ->
IO a
catchRecentManagerError :: forall a. IO a -> (RecentManagerError -> Text -> IO a) -> IO a
catchRecentManagerError = IO a -> (RecentManagerError -> Text -> IO a) -> IO a
forall err a.
GErrorClass err =>
IO a -> (err -> Text -> IO a) -> IO a
catchGErrorJustDomain
handleRecentManagerError ::
(RecentManagerError -> GErrorMessage -> IO a) ->
IO a ->
IO a
handleRecentManagerError :: forall a. (RecentManagerError -> Text -> IO a) -> IO a -> IO a
handleRecentManagerError = (RecentManagerError -> Text -> IO a) -> IO a -> IO a
forall err a.
GErrorClass err =>
(err -> Text -> IO a) -> IO a -> IO a
handleGErrorJustDomain
type instance O.ParentTypes RecentManagerError = '[]
instance O.HasParentTypes RecentManagerError
foreign import ccall "gtk_recent_manager_error_get_type" c_gtk_recent_manager_error_get_type ::
IO GType
instance B.Types.TypedObject RecentManagerError where
glibType :: IO GType
glibType = IO GType
c_gtk_recent_manager_error_get_type
instance B.Types.BoxedEnum RecentManagerError
data PropagationPhase =
PropagationPhaseNone
| PropagationPhaseCapture
| PropagationPhaseBubble
| PropagationPhaseTarget
| AnotherPropagationPhase Int
deriving (Int -> PropagationPhase -> ShowS
[PropagationPhase] -> ShowS
PropagationPhase -> String
(Int -> PropagationPhase -> ShowS)
-> (PropagationPhase -> String)
-> ([PropagationPhase] -> ShowS)
-> Show PropagationPhase
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PropagationPhase] -> ShowS
$cshowList :: [PropagationPhase] -> ShowS
show :: PropagationPhase -> String
$cshow :: PropagationPhase -> String
showsPrec :: Int -> PropagationPhase -> ShowS
$cshowsPrec :: Int -> PropagationPhase -> ShowS
Show, PropagationPhase -> PropagationPhase -> Bool
(PropagationPhase -> PropagationPhase -> Bool)
-> (PropagationPhase -> PropagationPhase -> Bool)
-> Eq PropagationPhase
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PropagationPhase -> PropagationPhase -> Bool
$c/= :: PropagationPhase -> PropagationPhase -> Bool
== :: PropagationPhase -> PropagationPhase -> Bool
$c== :: PropagationPhase -> PropagationPhase -> Bool
Eq)
instance P.Enum PropagationPhase where
fromEnum :: PropagationPhase -> Int
fromEnum PropagationPhase
PropagationPhaseNone = Int
0
fromEnum PropagationPhase
PropagationPhaseCapture = Int
1
fromEnum PropagationPhase
PropagationPhaseBubble = Int
2
fromEnum PropagationPhase
PropagationPhaseTarget = Int
3
fromEnum (AnotherPropagationPhase Int
k) = Int
k
toEnum :: Int -> PropagationPhase
toEnum Int
0 = PropagationPhase
PropagationPhaseNone
toEnum Int
1 = PropagationPhase
PropagationPhaseCapture
toEnum Int
2 = PropagationPhase
PropagationPhaseBubble
toEnum Int
3 = PropagationPhase
PropagationPhaseTarget
toEnum Int
k = Int -> PropagationPhase
AnotherPropagationPhase Int
k
instance P.Ord PropagationPhase where
compare :: PropagationPhase -> PropagationPhase -> Ordering
compare PropagationPhase
a PropagationPhase
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PropagationPhase -> Int
forall a. Enum a => a -> Int
P.fromEnum PropagationPhase
a) (PropagationPhase -> Int
forall a. Enum a => a -> Int
P.fromEnum PropagationPhase
b)
type instance O.ParentTypes PropagationPhase = '[]
instance O.HasParentTypes PropagationPhase
foreign import ccall "gtk_propagation_phase_get_type" c_gtk_propagation_phase_get_type ::
IO GType
instance B.Types.TypedObject PropagationPhase where
glibType :: IO GType
glibType = IO GType
c_gtk_propagation_phase_get_type
instance B.Types.BoxedEnum PropagationPhase
data PropagationLimit =
PropagationLimitNone
| PropagationLimitSameNative
| AnotherPropagationLimit Int
deriving (Int -> PropagationLimit -> ShowS
[PropagationLimit] -> ShowS
PropagationLimit -> String
(Int -> PropagationLimit -> ShowS)
-> (PropagationLimit -> String)
-> ([PropagationLimit] -> ShowS)
-> Show PropagationLimit
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PropagationLimit] -> ShowS
$cshowList :: [PropagationLimit] -> ShowS
show :: PropagationLimit -> String
$cshow :: PropagationLimit -> String
showsPrec :: Int -> PropagationLimit -> ShowS
$cshowsPrec :: Int -> PropagationLimit -> ShowS
Show, PropagationLimit -> PropagationLimit -> Bool
(PropagationLimit -> PropagationLimit -> Bool)
-> (PropagationLimit -> PropagationLimit -> Bool)
-> Eq PropagationLimit
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PropagationLimit -> PropagationLimit -> Bool
$c/= :: PropagationLimit -> PropagationLimit -> Bool
== :: PropagationLimit -> PropagationLimit -> Bool
$c== :: PropagationLimit -> PropagationLimit -> Bool
Eq)
instance P.Enum PropagationLimit where
fromEnum :: PropagationLimit -> Int
fromEnum PropagationLimit
PropagationLimitNone = Int
0
fromEnum PropagationLimit
PropagationLimitSameNative = Int
1
fromEnum (AnotherPropagationLimit Int
k) = Int
k
toEnum :: Int -> PropagationLimit
toEnum Int
0 = PropagationLimit
PropagationLimitNone
toEnum Int
1 = PropagationLimit
PropagationLimitSameNative
toEnum Int
k = Int -> PropagationLimit
AnotherPropagationLimit Int
k
instance P.Ord PropagationLimit where
compare :: PropagationLimit -> PropagationLimit -> Ordering
compare PropagationLimit
a PropagationLimit
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PropagationLimit -> Int
forall a. Enum a => a -> Int
P.fromEnum PropagationLimit
a) (PropagationLimit -> Int
forall a. Enum a => a -> Int
P.fromEnum PropagationLimit
b)
type instance O.ParentTypes PropagationLimit = '[]
instance O.HasParentTypes PropagationLimit
foreign import ccall "gtk_propagation_limit_get_type" c_gtk_propagation_limit_get_type ::
IO GType
instance B.Types.TypedObject PropagationLimit where
glibType :: IO GType
glibType = IO GType
c_gtk_propagation_limit_get_type
instance B.Types.BoxedEnum PropagationLimit
data PrintStatus =
PrintStatusInitial
| PrintStatusPreparing
| PrintStatusGeneratingData
| PrintStatusSendingData
| PrintStatusPending
| PrintStatusPendingIssue
| PrintStatusPrinting
| PrintStatusFinished
| PrintStatusFinishedAborted
| AnotherPrintStatus Int
deriving (Int -> PrintStatus -> ShowS
[PrintStatus] -> ShowS
PrintStatus -> String
(Int -> PrintStatus -> ShowS)
-> (PrintStatus -> String)
-> ([PrintStatus] -> ShowS)
-> Show PrintStatus
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PrintStatus] -> ShowS
$cshowList :: [PrintStatus] -> ShowS
show :: PrintStatus -> String
$cshow :: PrintStatus -> String
showsPrec :: Int -> PrintStatus -> ShowS
$cshowsPrec :: Int -> PrintStatus -> ShowS
Show, PrintStatus -> PrintStatus -> Bool
(PrintStatus -> PrintStatus -> Bool)
-> (PrintStatus -> PrintStatus -> Bool) -> Eq PrintStatus
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PrintStatus -> PrintStatus -> Bool
$c/= :: PrintStatus -> PrintStatus -> Bool
== :: PrintStatus -> PrintStatus -> Bool
$c== :: PrintStatus -> PrintStatus -> Bool
Eq)
instance P.Enum PrintStatus where
fromEnum :: PrintStatus -> Int
fromEnum PrintStatus
PrintStatusInitial = Int
0
fromEnum PrintStatus
PrintStatusPreparing = Int
1
fromEnum PrintStatus
PrintStatusGeneratingData = Int
2
fromEnum PrintStatus
PrintStatusSendingData = Int
3
fromEnum PrintStatus
PrintStatusPending = Int
4
fromEnum PrintStatus
PrintStatusPendingIssue = Int
5
fromEnum PrintStatus
PrintStatusPrinting = Int
6
fromEnum PrintStatus
PrintStatusFinished = Int
7
fromEnum PrintStatus
PrintStatusFinishedAborted = Int
8
fromEnum (AnotherPrintStatus Int
k) = Int
k
toEnum :: Int -> PrintStatus
toEnum Int
0 = PrintStatus
PrintStatusInitial
toEnum Int
1 = PrintStatus
PrintStatusPreparing
toEnum Int
2 = PrintStatus
PrintStatusGeneratingData
toEnum Int
3 = PrintStatus
PrintStatusSendingData
toEnum Int
4 = PrintStatus
PrintStatusPending
toEnum Int
5 = PrintStatus
PrintStatusPendingIssue
toEnum Int
6 = PrintStatus
PrintStatusPrinting
toEnum Int
7 = PrintStatus
PrintStatusFinished
toEnum Int
8 = PrintStatus
PrintStatusFinishedAborted
toEnum Int
k = Int -> PrintStatus
AnotherPrintStatus Int
k
instance P.Ord PrintStatus where
compare :: PrintStatus -> PrintStatus -> Ordering
compare PrintStatus
a PrintStatus
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PrintStatus -> Int
forall a. Enum a => a -> Int
P.fromEnum PrintStatus
a) (PrintStatus -> Int
forall a. Enum a => a -> Int
P.fromEnum PrintStatus
b)
type instance O.ParentTypes PrintStatus = '[]
instance O.HasParentTypes PrintStatus
foreign import ccall "gtk_print_status_get_type" c_gtk_print_status_get_type ::
IO GType
instance B.Types.TypedObject PrintStatus where
glibType :: IO GType
glibType = IO GType
c_gtk_print_status_get_type
instance B.Types.BoxedEnum PrintStatus
data PrintQuality =
PrintQualityLow
| PrintQualityNormal
| PrintQualityHigh
| PrintQualityDraft
| AnotherPrintQuality Int
deriving (Int -> PrintQuality -> ShowS
[PrintQuality] -> ShowS
PrintQuality -> String
(Int -> PrintQuality -> ShowS)
-> (PrintQuality -> String)
-> ([PrintQuality] -> ShowS)
-> Show PrintQuality
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PrintQuality] -> ShowS
$cshowList :: [PrintQuality] -> ShowS
show :: PrintQuality -> String
$cshow :: PrintQuality -> String
showsPrec :: Int -> PrintQuality -> ShowS
$cshowsPrec :: Int -> PrintQuality -> ShowS
Show, PrintQuality -> PrintQuality -> Bool
(PrintQuality -> PrintQuality -> Bool)
-> (PrintQuality -> PrintQuality -> Bool) -> Eq PrintQuality
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PrintQuality -> PrintQuality -> Bool
$c/= :: PrintQuality -> PrintQuality -> Bool
== :: PrintQuality -> PrintQuality -> Bool
$c== :: PrintQuality -> PrintQuality -> Bool
Eq)
instance P.Enum PrintQuality where
fromEnum :: PrintQuality -> Int
fromEnum PrintQuality
PrintQualityLow = Int
0
fromEnum PrintQuality
PrintQualityNormal = Int
1
fromEnum PrintQuality
PrintQualityHigh = Int
2
fromEnum PrintQuality
PrintQualityDraft = Int
3
fromEnum (AnotherPrintQuality Int
k) = Int
k
toEnum :: Int -> PrintQuality
toEnum Int
0 = PrintQuality
PrintQualityLow
toEnum Int
1 = PrintQuality
PrintQualityNormal
toEnum Int
2 = PrintQuality
PrintQualityHigh
toEnum Int
3 = PrintQuality
PrintQualityDraft
toEnum Int
k = Int -> PrintQuality
AnotherPrintQuality Int
k
instance P.Ord PrintQuality where
compare :: PrintQuality -> PrintQuality -> Ordering
compare PrintQuality
a PrintQuality
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PrintQuality -> Int
forall a. Enum a => a -> Int
P.fromEnum PrintQuality
a) (PrintQuality -> Int
forall a. Enum a => a -> Int
P.fromEnum PrintQuality
b)
type instance O.ParentTypes PrintQuality = '[]
instance O.HasParentTypes PrintQuality
foreign import ccall "gtk_print_quality_get_type" c_gtk_print_quality_get_type ::
IO GType
instance B.Types.TypedObject PrintQuality where
glibType :: IO GType
glibType = IO GType
c_gtk_print_quality_get_type
instance B.Types.BoxedEnum PrintQuality
data PrintPages =
PrintPagesAll
| PrintPagesCurrent
| PrintPagesRanges
| PrintPagesSelection
| AnotherPrintPages Int
deriving (Int -> PrintPages -> ShowS
[PrintPages] -> ShowS
PrintPages -> String
(Int -> PrintPages -> ShowS)
-> (PrintPages -> String)
-> ([PrintPages] -> ShowS)
-> Show PrintPages
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PrintPages] -> ShowS
$cshowList :: [PrintPages] -> ShowS
show :: PrintPages -> String
$cshow :: PrintPages -> String
showsPrec :: Int -> PrintPages -> ShowS
$cshowsPrec :: Int -> PrintPages -> ShowS
Show, PrintPages -> PrintPages -> Bool
(PrintPages -> PrintPages -> Bool)
-> (PrintPages -> PrintPages -> Bool) -> Eq PrintPages
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PrintPages -> PrintPages -> Bool
$c/= :: PrintPages -> PrintPages -> Bool
== :: PrintPages -> PrintPages -> Bool
$c== :: PrintPages -> PrintPages -> Bool
Eq)
instance P.Enum PrintPages where
fromEnum :: PrintPages -> Int
fromEnum PrintPages
PrintPagesAll = Int
0
fromEnum PrintPages
PrintPagesCurrent = Int
1
fromEnum PrintPages
PrintPagesRanges = Int
2
fromEnum PrintPages
PrintPagesSelection = Int
3
fromEnum (AnotherPrintPages Int
k) = Int
k
toEnum :: Int -> PrintPages
toEnum Int
0 = PrintPages
PrintPagesAll
toEnum Int
1 = PrintPages
PrintPagesCurrent
toEnum Int
2 = PrintPages
PrintPagesRanges
toEnum Int
3 = PrintPages
PrintPagesSelection
toEnum Int
k = Int -> PrintPages
AnotherPrintPages Int
k
instance P.Ord PrintPages where
compare :: PrintPages -> PrintPages -> Ordering
compare PrintPages
a PrintPages
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PrintPages -> Int
forall a. Enum a => a -> Int
P.fromEnum PrintPages
a) (PrintPages -> Int
forall a. Enum a => a -> Int
P.fromEnum PrintPages
b)
type instance O.ParentTypes PrintPages = '[]
instance O.HasParentTypes PrintPages
foreign import ccall "gtk_print_pages_get_type" c_gtk_print_pages_get_type ::
IO GType
instance B.Types.TypedObject PrintPages where
glibType :: IO GType
glibType = IO GType
c_gtk_print_pages_get_type
instance B.Types.BoxedEnum PrintPages
data PrintOperationResult =
PrintOperationResultError
| PrintOperationResultApply
| PrintOperationResultCancel
| PrintOperationResultInProgress
| AnotherPrintOperationResult Int
deriving (Int -> PrintOperationResult -> ShowS
[PrintOperationResult] -> ShowS
PrintOperationResult -> String
(Int -> PrintOperationResult -> ShowS)
-> (PrintOperationResult -> String)
-> ([PrintOperationResult] -> ShowS)
-> Show PrintOperationResult
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PrintOperationResult] -> ShowS
$cshowList :: [PrintOperationResult] -> ShowS
show :: PrintOperationResult -> String
$cshow :: PrintOperationResult -> String
showsPrec :: Int -> PrintOperationResult -> ShowS
$cshowsPrec :: Int -> PrintOperationResult -> ShowS
Show, PrintOperationResult -> PrintOperationResult -> Bool
(PrintOperationResult -> PrintOperationResult -> Bool)
-> (PrintOperationResult -> PrintOperationResult -> Bool)
-> Eq PrintOperationResult
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PrintOperationResult -> PrintOperationResult -> Bool
$c/= :: PrintOperationResult -> PrintOperationResult -> Bool
== :: PrintOperationResult -> PrintOperationResult -> Bool
$c== :: PrintOperationResult -> PrintOperationResult -> Bool
Eq)
instance P.Enum PrintOperationResult where
fromEnum :: PrintOperationResult -> Int
fromEnum PrintOperationResult
PrintOperationResultError = Int
0
fromEnum PrintOperationResult
PrintOperationResultApply = Int
1
fromEnum PrintOperationResult
PrintOperationResultCancel = Int
2
fromEnum PrintOperationResult
PrintOperationResultInProgress = Int
3
fromEnum (AnotherPrintOperationResult Int
k) = Int
k
toEnum :: Int -> PrintOperationResult
toEnum Int
0 = PrintOperationResult
PrintOperationResultError
toEnum Int
1 = PrintOperationResult
PrintOperationResultApply
toEnum Int
2 = PrintOperationResult
PrintOperationResultCancel
toEnum Int
3 = PrintOperationResult
PrintOperationResultInProgress
toEnum Int
k = Int -> PrintOperationResult
AnotherPrintOperationResult Int
k
instance P.Ord PrintOperationResult where
compare :: PrintOperationResult -> PrintOperationResult -> Ordering
compare PrintOperationResult
a PrintOperationResult
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PrintOperationResult -> Int
forall a. Enum a => a -> Int
P.fromEnum PrintOperationResult
a) (PrintOperationResult -> Int
forall a. Enum a => a -> Int
P.fromEnum PrintOperationResult
b)
type instance O.ParentTypes PrintOperationResult = '[]
instance O.HasParentTypes PrintOperationResult
foreign import ccall "gtk_print_operation_result_get_type" c_gtk_print_operation_result_get_type ::
IO GType
instance B.Types.TypedObject PrintOperationResult where
glibType :: IO GType
glibType = IO GType
c_gtk_print_operation_result_get_type
instance B.Types.BoxedEnum PrintOperationResult
data PrintOperationAction =
PrintOperationActionPrintDialog
| PrintOperationActionPrint
| PrintOperationActionPreview
| PrintOperationActionExport
| AnotherPrintOperationAction Int
deriving (Int -> PrintOperationAction -> ShowS
[PrintOperationAction] -> ShowS
PrintOperationAction -> String
(Int -> PrintOperationAction -> ShowS)
-> (PrintOperationAction -> String)
-> ([PrintOperationAction] -> ShowS)
-> Show PrintOperationAction
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PrintOperationAction] -> ShowS
$cshowList :: [PrintOperationAction] -> ShowS
show :: PrintOperationAction -> String
$cshow :: PrintOperationAction -> String
showsPrec :: Int -> PrintOperationAction -> ShowS
$cshowsPrec :: Int -> PrintOperationAction -> ShowS
Show, PrintOperationAction -> PrintOperationAction -> Bool
(PrintOperationAction -> PrintOperationAction -> Bool)
-> (PrintOperationAction -> PrintOperationAction -> Bool)
-> Eq PrintOperationAction
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PrintOperationAction -> PrintOperationAction -> Bool
$c/= :: PrintOperationAction -> PrintOperationAction -> Bool
== :: PrintOperationAction -> PrintOperationAction -> Bool
$c== :: PrintOperationAction -> PrintOperationAction -> Bool
Eq)
instance P.Enum PrintOperationAction where
fromEnum :: PrintOperationAction -> Int
fromEnum PrintOperationAction
PrintOperationActionPrintDialog = Int
0
fromEnum PrintOperationAction
PrintOperationActionPrint = Int
1
fromEnum PrintOperationAction
PrintOperationActionPreview = Int
2
fromEnum PrintOperationAction
PrintOperationActionExport = Int
3
fromEnum (AnotherPrintOperationAction Int
k) = Int
k
toEnum :: Int -> PrintOperationAction
toEnum Int
0 = PrintOperationAction
PrintOperationActionPrintDialog
toEnum Int
1 = PrintOperationAction
PrintOperationActionPrint
toEnum Int
2 = PrintOperationAction
PrintOperationActionPreview
toEnum Int
3 = PrintOperationAction
PrintOperationActionExport
toEnum Int
k = Int -> PrintOperationAction
AnotherPrintOperationAction Int
k
instance P.Ord PrintOperationAction where
compare :: PrintOperationAction -> PrintOperationAction -> Ordering
compare PrintOperationAction
a PrintOperationAction
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PrintOperationAction -> Int
forall a. Enum a => a -> Int
P.fromEnum PrintOperationAction
a) (PrintOperationAction -> Int
forall a. Enum a => a -> Int
P.fromEnum PrintOperationAction
b)
type instance O.ParentTypes PrintOperationAction = '[]
instance O.HasParentTypes PrintOperationAction
foreign import ccall "gtk_print_operation_action_get_type" c_gtk_print_operation_action_get_type ::
IO GType
instance B.Types.TypedObject PrintOperationAction where
glibType :: IO GType
glibType = IO GType
c_gtk_print_operation_action_get_type
instance B.Types.BoxedEnum PrintOperationAction
data PrintError =
PrintErrorGeneral
| PrintErrorInternalError
| PrintErrorNomem
| PrintErrorInvalidFile
| AnotherPrintError Int
deriving (Int -> PrintError -> ShowS
[PrintError] -> ShowS
PrintError -> String
(Int -> PrintError -> ShowS)
-> (PrintError -> String)
-> ([PrintError] -> ShowS)
-> Show PrintError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PrintError] -> ShowS
$cshowList :: [PrintError] -> ShowS
show :: PrintError -> String
$cshow :: PrintError -> String
showsPrec :: Int -> PrintError -> ShowS
$cshowsPrec :: Int -> PrintError -> ShowS
Show, PrintError -> PrintError -> Bool
(PrintError -> PrintError -> Bool)
-> (PrintError -> PrintError -> Bool) -> Eq PrintError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PrintError -> PrintError -> Bool
$c/= :: PrintError -> PrintError -> Bool
== :: PrintError -> PrintError -> Bool
$c== :: PrintError -> PrintError -> Bool
Eq)
instance P.Enum PrintError where
fromEnum :: PrintError -> Int
fromEnum PrintError
PrintErrorGeneral = Int
0
fromEnum PrintError
PrintErrorInternalError = Int
1
fromEnum PrintError
PrintErrorNomem = Int
2
fromEnum PrintError
PrintErrorInvalidFile = Int
3
fromEnum (AnotherPrintError Int
k) = Int
k
toEnum :: Int -> PrintError
toEnum Int
0 = PrintError
PrintErrorGeneral
toEnum Int
1 = PrintError
PrintErrorInternalError
toEnum Int
2 = PrintError
PrintErrorNomem
toEnum Int
3 = PrintError
PrintErrorInvalidFile
toEnum Int
k = Int -> PrintError
AnotherPrintError Int
k
instance P.Ord PrintError where
compare :: PrintError -> PrintError -> Ordering
compare PrintError
a PrintError
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PrintError -> Int
forall a. Enum a => a -> Int
P.fromEnum PrintError
a) (PrintError -> Int
forall a. Enum a => a -> Int
P.fromEnum PrintError
b)
instance GErrorClass PrintError where
gerrorClassDomain :: PrintError -> Text
gerrorClassDomain PrintError
_ = Text
"gtk-print-error-quark"
catchPrintError ::
IO a ->
(PrintError -> GErrorMessage -> IO a) ->
IO a
catchPrintError :: forall a. IO a -> (PrintError -> Text -> IO a) -> IO a
catchPrintError = IO a -> (PrintError -> Text -> IO a) -> IO a
forall err a.
GErrorClass err =>
IO a -> (err -> Text -> IO a) -> IO a
catchGErrorJustDomain
handlePrintError ::
(PrintError -> GErrorMessage -> IO a) ->
IO a ->
IO a
handlePrintError :: forall a. (PrintError -> Text -> IO a) -> IO a -> IO a
handlePrintError = (PrintError -> Text -> IO a) -> IO a -> IO a
forall err a.
GErrorClass err =>
(err -> Text -> IO a) -> IO a -> IO a
handleGErrorJustDomain
type instance O.ParentTypes PrintError = '[]
instance O.HasParentTypes PrintError
foreign import ccall "gtk_print_error_get_type" c_gtk_print_error_get_type ::
IO GType
instance B.Types.TypedObject PrintError where
glibType :: IO GType
glibType = IO GType
c_gtk_print_error_get_type
instance B.Types.BoxedEnum PrintError
data PrintDuplex =
PrintDuplexSimplex
| PrintDuplexHorizontal
| PrintDuplexVertical
| AnotherPrintDuplex Int
deriving (Int -> PrintDuplex -> ShowS
[PrintDuplex] -> ShowS
PrintDuplex -> String
(Int -> PrintDuplex -> ShowS)
-> (PrintDuplex -> String)
-> ([PrintDuplex] -> ShowS)
-> Show PrintDuplex
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PrintDuplex] -> ShowS
$cshowList :: [PrintDuplex] -> ShowS
show :: PrintDuplex -> String
$cshow :: PrintDuplex -> String
showsPrec :: Int -> PrintDuplex -> ShowS
$cshowsPrec :: Int -> PrintDuplex -> ShowS
Show, PrintDuplex -> PrintDuplex -> Bool
(PrintDuplex -> PrintDuplex -> Bool)
-> (PrintDuplex -> PrintDuplex -> Bool) -> Eq PrintDuplex
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PrintDuplex -> PrintDuplex -> Bool
$c/= :: PrintDuplex -> PrintDuplex -> Bool
== :: PrintDuplex -> PrintDuplex -> Bool
$c== :: PrintDuplex -> PrintDuplex -> Bool
Eq)
instance P.Enum PrintDuplex where
fromEnum :: PrintDuplex -> Int
fromEnum PrintDuplex
PrintDuplexSimplex = Int
0
fromEnum PrintDuplex
PrintDuplexHorizontal = Int
1
fromEnum PrintDuplex
PrintDuplexVertical = Int
2
fromEnum (AnotherPrintDuplex Int
k) = Int
k
toEnum :: Int -> PrintDuplex
toEnum Int
0 = PrintDuplex
PrintDuplexSimplex
toEnum Int
1 = PrintDuplex
PrintDuplexHorizontal
toEnum Int
2 = PrintDuplex
PrintDuplexVertical
toEnum Int
k = Int -> PrintDuplex
AnotherPrintDuplex Int
k
instance P.Ord PrintDuplex where
compare :: PrintDuplex -> PrintDuplex -> Ordering
compare PrintDuplex
a PrintDuplex
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PrintDuplex -> Int
forall a. Enum a => a -> Int
P.fromEnum PrintDuplex
a) (PrintDuplex -> Int
forall a. Enum a => a -> Int
P.fromEnum PrintDuplex
b)
type instance O.ParentTypes PrintDuplex = '[]
instance O.HasParentTypes PrintDuplex
foreign import ccall "gtk_print_duplex_get_type" c_gtk_print_duplex_get_type ::
IO GType
instance B.Types.TypedObject PrintDuplex where
glibType :: IO GType
glibType = IO GType
c_gtk_print_duplex_get_type
instance B.Types.BoxedEnum PrintDuplex
data PositionType =
PositionTypeLeft
| PositionTypeRight
| PositionTypeTop
| PositionTypeBottom
| AnotherPositionType Int
deriving (Int -> PositionType -> ShowS
[PositionType] -> ShowS
PositionType -> String
(Int -> PositionType -> ShowS)
-> (PositionType -> String)
-> ([PositionType] -> ShowS)
-> Show PositionType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PositionType] -> ShowS
$cshowList :: [PositionType] -> ShowS
show :: PositionType -> String
$cshow :: PositionType -> String
showsPrec :: Int -> PositionType -> ShowS
$cshowsPrec :: Int -> PositionType -> ShowS
Show, PositionType -> PositionType -> Bool
(PositionType -> PositionType -> Bool)
-> (PositionType -> PositionType -> Bool) -> Eq PositionType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PositionType -> PositionType -> Bool
$c/= :: PositionType -> PositionType -> Bool
== :: PositionType -> PositionType -> Bool
$c== :: PositionType -> PositionType -> Bool
Eq)
instance P.Enum PositionType where
fromEnum :: PositionType -> Int
fromEnum PositionType
PositionTypeLeft = Int
0
fromEnum PositionType
PositionTypeRight = Int
1
fromEnum PositionType
PositionTypeTop = Int
2
fromEnum PositionType
PositionTypeBottom = Int
3
fromEnum (AnotherPositionType Int
k) = Int
k
toEnum :: Int -> PositionType
toEnum Int
0 = PositionType
PositionTypeLeft
toEnum Int
1 = PositionType
PositionTypeRight
toEnum Int
2 = PositionType
PositionTypeTop
toEnum Int
3 = PositionType
PositionTypeBottom
toEnum Int
k = Int -> PositionType
AnotherPositionType Int
k
instance P.Ord PositionType where
compare :: PositionType -> PositionType -> Ordering
compare PositionType
a PositionType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PositionType -> Int
forall a. Enum a => a -> Int
P.fromEnum PositionType
a) (PositionType -> Int
forall a. Enum a => a -> Int
P.fromEnum PositionType
b)
type instance O.ParentTypes PositionType = '[]
instance O.HasParentTypes PositionType
foreign import ccall "gtk_position_type_get_type" c_gtk_position_type_get_type ::
IO GType
instance B.Types.TypedObject PositionType where
glibType :: IO GType
glibType = IO GType
c_gtk_position_type_get_type
instance B.Types.BoxedEnum PositionType
data PolicyType =
PolicyTypeAlways
| PolicyTypeAutomatic
| PolicyTypeNever
| PolicyTypeExternal
| AnotherPolicyType Int
deriving (Int -> PolicyType -> ShowS
[PolicyType] -> ShowS
PolicyType -> String
(Int -> PolicyType -> ShowS)
-> (PolicyType -> String)
-> ([PolicyType] -> ShowS)
-> Show PolicyType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PolicyType] -> ShowS
$cshowList :: [PolicyType] -> ShowS
show :: PolicyType -> String
$cshow :: PolicyType -> String
showsPrec :: Int -> PolicyType -> ShowS
$cshowsPrec :: Int -> PolicyType -> ShowS
Show, PolicyType -> PolicyType -> Bool
(PolicyType -> PolicyType -> Bool)
-> (PolicyType -> PolicyType -> Bool) -> Eq PolicyType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PolicyType -> PolicyType -> Bool
$c/= :: PolicyType -> PolicyType -> Bool
== :: PolicyType -> PolicyType -> Bool
$c== :: PolicyType -> PolicyType -> Bool
Eq)
instance P.Enum PolicyType where
fromEnum :: PolicyType -> Int
fromEnum PolicyType
PolicyTypeAlways = Int
0
fromEnum PolicyType
PolicyTypeAutomatic = Int
1
fromEnum PolicyType
PolicyTypeNever = Int
2
fromEnum PolicyType
PolicyTypeExternal = Int
3
fromEnum (AnotherPolicyType Int
k) = Int
k
toEnum :: Int -> PolicyType
toEnum Int
0 = PolicyType
PolicyTypeAlways
toEnum Int
1 = PolicyType
PolicyTypeAutomatic
toEnum Int
2 = PolicyType
PolicyTypeNever
toEnum Int
3 = PolicyType
PolicyTypeExternal
toEnum Int
k = Int -> PolicyType
AnotherPolicyType Int
k
instance P.Ord PolicyType where
compare :: PolicyType -> PolicyType -> Ordering
compare PolicyType
a PolicyType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PolicyType -> Int
forall a. Enum a => a -> Int
P.fromEnum PolicyType
a) (PolicyType -> Int
forall a. Enum a => a -> Int
P.fromEnum PolicyType
b)
type instance O.ParentTypes PolicyType = '[]
instance O.HasParentTypes PolicyType
foreign import ccall "gtk_policy_type_get_type" c_gtk_policy_type_get_type ::
IO GType
instance B.Types.TypedObject PolicyType where
glibType :: IO GType
glibType = IO GType
c_gtk_policy_type_get_type
instance B.Types.BoxedEnum PolicyType
data PanDirection =
PanDirectionLeft
| PanDirectionRight
| PanDirectionUp
| PanDirectionDown
| AnotherPanDirection Int
deriving (Int -> PanDirection -> ShowS
[PanDirection] -> ShowS
PanDirection -> String
(Int -> PanDirection -> ShowS)
-> (PanDirection -> String)
-> ([PanDirection] -> ShowS)
-> Show PanDirection
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PanDirection] -> ShowS
$cshowList :: [PanDirection] -> ShowS
show :: PanDirection -> String
$cshow :: PanDirection -> String
showsPrec :: Int -> PanDirection -> ShowS
$cshowsPrec :: Int -> PanDirection -> ShowS
Show, PanDirection -> PanDirection -> Bool
(PanDirection -> PanDirection -> Bool)
-> (PanDirection -> PanDirection -> Bool) -> Eq PanDirection
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PanDirection -> PanDirection -> Bool
$c/= :: PanDirection -> PanDirection -> Bool
== :: PanDirection -> PanDirection -> Bool
$c== :: PanDirection -> PanDirection -> Bool
Eq)
instance P.Enum PanDirection where
fromEnum :: PanDirection -> Int
fromEnum PanDirection
PanDirectionLeft = Int
0
fromEnum PanDirection
PanDirectionRight = Int
1
fromEnum PanDirection
PanDirectionUp = Int
2
fromEnum PanDirection
PanDirectionDown = Int
3
fromEnum (AnotherPanDirection Int
k) = Int
k
toEnum :: Int -> PanDirection
toEnum Int
0 = PanDirection
PanDirectionLeft
toEnum Int
1 = PanDirection
PanDirectionRight
toEnum Int
2 = PanDirection
PanDirectionUp
toEnum Int
3 = PanDirection
PanDirectionDown
toEnum Int
k = Int -> PanDirection
AnotherPanDirection Int
k
instance P.Ord PanDirection where
compare :: PanDirection -> PanDirection -> Ordering
compare PanDirection
a PanDirection
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PanDirection -> Int
forall a. Enum a => a -> Int
P.fromEnum PanDirection
a) (PanDirection -> Int
forall a. Enum a => a -> Int
P.fromEnum PanDirection
b)
type instance O.ParentTypes PanDirection = '[]
instance O.HasParentTypes PanDirection
foreign import ccall "gtk_pan_direction_get_type" c_gtk_pan_direction_get_type ::
IO GType
instance B.Types.TypedObject PanDirection where
glibType :: IO GType
glibType = IO GType
c_gtk_pan_direction_get_type
instance B.Types.BoxedEnum PanDirection
data PageSet =
PageSetAll
| PageSetEven
| PageSetOdd
| AnotherPageSet Int
deriving (Int -> PageSet -> ShowS
[PageSet] -> ShowS
PageSet -> String
(Int -> PageSet -> ShowS)
-> (PageSet -> String) -> ([PageSet] -> ShowS) -> Show PageSet
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PageSet] -> ShowS
$cshowList :: [PageSet] -> ShowS
show :: PageSet -> String
$cshow :: PageSet -> String
showsPrec :: Int -> PageSet -> ShowS
$cshowsPrec :: Int -> PageSet -> ShowS
Show, PageSet -> PageSet -> Bool
(PageSet -> PageSet -> Bool)
-> (PageSet -> PageSet -> Bool) -> Eq PageSet
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PageSet -> PageSet -> Bool
$c/= :: PageSet -> PageSet -> Bool
== :: PageSet -> PageSet -> Bool
$c== :: PageSet -> PageSet -> Bool
Eq)
instance P.Enum PageSet where
fromEnum :: PageSet -> Int
fromEnum PageSet
PageSetAll = Int
0
fromEnum PageSet
PageSetEven = Int
1
fromEnum PageSet
PageSetOdd = Int
2
fromEnum (AnotherPageSet Int
k) = Int
k
toEnum :: Int -> PageSet
toEnum Int
0 = PageSet
PageSetAll
toEnum Int
1 = PageSet
PageSetEven
toEnum Int
2 = PageSet
PageSetOdd
toEnum Int
k = Int -> PageSet
AnotherPageSet Int
k
instance P.Ord PageSet where
compare :: PageSet -> PageSet -> Ordering
compare PageSet
a PageSet
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PageSet -> Int
forall a. Enum a => a -> Int
P.fromEnum PageSet
a) (PageSet -> Int
forall a. Enum a => a -> Int
P.fromEnum PageSet
b)
type instance O.ParentTypes PageSet = '[]
instance O.HasParentTypes PageSet
foreign import ccall "gtk_page_set_get_type" c_gtk_page_set_get_type ::
IO GType
instance B.Types.TypedObject PageSet where
glibType :: IO GType
glibType = IO GType
c_gtk_page_set_get_type
instance B.Types.BoxedEnum PageSet
data PageOrientation =
PageOrientationPortrait
| PageOrientationLandscape
| PageOrientationReversePortrait
| PageOrientationReverseLandscape
| AnotherPageOrientation Int
deriving (Int -> PageOrientation -> ShowS
[PageOrientation] -> ShowS
PageOrientation -> String
(Int -> PageOrientation -> ShowS)
-> (PageOrientation -> String)
-> ([PageOrientation] -> ShowS)
-> Show PageOrientation
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PageOrientation] -> ShowS
$cshowList :: [PageOrientation] -> ShowS
show :: PageOrientation -> String
$cshow :: PageOrientation -> String
showsPrec :: Int -> PageOrientation -> ShowS
$cshowsPrec :: Int -> PageOrientation -> ShowS
Show, PageOrientation -> PageOrientation -> Bool
(PageOrientation -> PageOrientation -> Bool)
-> (PageOrientation -> PageOrientation -> Bool)
-> Eq PageOrientation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PageOrientation -> PageOrientation -> Bool
$c/= :: PageOrientation -> PageOrientation -> Bool
== :: PageOrientation -> PageOrientation -> Bool
$c== :: PageOrientation -> PageOrientation -> Bool
Eq)
instance P.Enum PageOrientation where
fromEnum :: PageOrientation -> Int
fromEnum PageOrientation
PageOrientationPortrait = Int
0
fromEnum PageOrientation
PageOrientationLandscape = Int
1
fromEnum PageOrientation
PageOrientationReversePortrait = Int
2
fromEnum PageOrientation
PageOrientationReverseLandscape = Int
3
fromEnum (AnotherPageOrientation Int
k) = Int
k
toEnum :: Int -> PageOrientation
toEnum Int
0 = PageOrientation
PageOrientationPortrait
toEnum Int
1 = PageOrientation
PageOrientationLandscape
toEnum Int
2 = PageOrientation
PageOrientationReversePortrait
toEnum Int
3 = PageOrientation
PageOrientationReverseLandscape
toEnum Int
k = Int -> PageOrientation
AnotherPageOrientation Int
k
instance P.Ord PageOrientation where
compare :: PageOrientation -> PageOrientation -> Ordering
compare PageOrientation
a PageOrientation
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PageOrientation -> Int
forall a. Enum a => a -> Int
P.fromEnum PageOrientation
a) (PageOrientation -> Int
forall a. Enum a => a -> Int
P.fromEnum PageOrientation
b)
type instance O.ParentTypes PageOrientation = '[]
instance O.HasParentTypes PageOrientation
foreign import ccall "gtk_page_orientation_get_type" c_gtk_page_orientation_get_type ::
IO GType
instance B.Types.TypedObject PageOrientation where
glibType :: IO GType
glibType = IO GType
c_gtk_page_orientation_get_type
instance B.Types.BoxedEnum PageOrientation
data PadActionType =
PadActionTypeButton
| PadActionTypeRing
| PadActionTypeStrip
| AnotherPadActionType Int
deriving (Int -> PadActionType -> ShowS
[PadActionType] -> ShowS
PadActionType -> String
(Int -> PadActionType -> ShowS)
-> (PadActionType -> String)
-> ([PadActionType] -> ShowS)
-> Show PadActionType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PadActionType] -> ShowS
$cshowList :: [PadActionType] -> ShowS
show :: PadActionType -> String
$cshow :: PadActionType -> String
showsPrec :: Int -> PadActionType -> ShowS
$cshowsPrec :: Int -> PadActionType -> ShowS
Show, PadActionType -> PadActionType -> Bool
(PadActionType -> PadActionType -> Bool)
-> (PadActionType -> PadActionType -> Bool) -> Eq PadActionType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PadActionType -> PadActionType -> Bool
$c/= :: PadActionType -> PadActionType -> Bool
== :: PadActionType -> PadActionType -> Bool
$c== :: PadActionType -> PadActionType -> Bool
Eq)
instance P.Enum PadActionType where
fromEnum :: PadActionType -> Int
fromEnum PadActionType
PadActionTypeButton = Int
0
fromEnum PadActionType
PadActionTypeRing = Int
1
fromEnum PadActionType
PadActionTypeStrip = Int
2
fromEnum (AnotherPadActionType Int
k) = Int
k
toEnum :: Int -> PadActionType
toEnum Int
0 = PadActionType
PadActionTypeButton
toEnum Int
1 = PadActionType
PadActionTypeRing
toEnum Int
2 = PadActionType
PadActionTypeStrip
toEnum Int
k = Int -> PadActionType
AnotherPadActionType Int
k
instance P.Ord PadActionType where
compare :: PadActionType -> PadActionType -> Ordering
compare PadActionType
a PadActionType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PadActionType -> Int
forall a. Enum a => a -> Int
P.fromEnum PadActionType
a) (PadActionType -> Int
forall a. Enum a => a -> Int
P.fromEnum PadActionType
b)
type instance O.ParentTypes PadActionType = '[]
instance O.HasParentTypes PadActionType
foreign import ccall "gtk_pad_action_type_get_type" c_gtk_pad_action_type_get_type ::
IO GType
instance B.Types.TypedObject PadActionType where
glibType :: IO GType
glibType = IO GType
c_gtk_pad_action_type_get_type
instance B.Types.BoxedEnum PadActionType
data PackType =
PackTypeStart
| PackTypeEnd
| AnotherPackType Int
deriving (Int -> PackType -> ShowS
[PackType] -> ShowS
PackType -> String
(Int -> PackType -> ShowS)
-> (PackType -> String) -> ([PackType] -> ShowS) -> Show PackType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PackType] -> ShowS
$cshowList :: [PackType] -> ShowS
show :: PackType -> String
$cshow :: PackType -> String
showsPrec :: Int -> PackType -> ShowS
$cshowsPrec :: Int -> PackType -> ShowS
Show, PackType -> PackType -> Bool
(PackType -> PackType -> Bool)
-> (PackType -> PackType -> Bool) -> Eq PackType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PackType -> PackType -> Bool
$c/= :: PackType -> PackType -> Bool
== :: PackType -> PackType -> Bool
$c== :: PackType -> PackType -> Bool
Eq)
instance P.Enum PackType where
fromEnum :: PackType -> Int
fromEnum PackType
PackTypeStart = Int
0
fromEnum PackType
PackTypeEnd = Int
1
fromEnum (AnotherPackType Int
k) = Int
k
toEnum :: Int -> PackType
toEnum Int
0 = PackType
PackTypeStart
toEnum Int
1 = PackType
PackTypeEnd
toEnum Int
k = Int -> PackType
AnotherPackType Int
k
instance P.Ord PackType where
compare :: PackType -> PackType -> Ordering
compare PackType
a PackType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PackType -> Int
forall a. Enum a => a -> Int
P.fromEnum PackType
a) (PackType -> Int
forall a. Enum a => a -> Int
P.fromEnum PackType
b)
type instance O.ParentTypes PackType = '[]
instance O.HasParentTypes PackType
foreign import ccall "gtk_pack_type_get_type" c_gtk_pack_type_get_type ::
IO GType
instance B.Types.TypedObject PackType where
glibType :: IO GType
glibType = IO GType
c_gtk_pack_type_get_type
instance B.Types.BoxedEnum PackType
data Overflow =
OverflowVisible
| OverflowHidden
| AnotherOverflow Int
deriving (Int -> Overflow -> ShowS
[Overflow] -> ShowS
Overflow -> String
(Int -> Overflow -> ShowS)
-> (Overflow -> String) -> ([Overflow] -> ShowS) -> Show Overflow
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Overflow] -> ShowS
$cshowList :: [Overflow] -> ShowS
show :: Overflow -> String
$cshow :: Overflow -> String
showsPrec :: Int -> Overflow -> ShowS
$cshowsPrec :: Int -> Overflow -> ShowS
Show, Overflow -> Overflow -> Bool
(Overflow -> Overflow -> Bool)
-> (Overflow -> Overflow -> Bool) -> Eq Overflow
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Overflow -> Overflow -> Bool
$c/= :: Overflow -> Overflow -> Bool
== :: Overflow -> Overflow -> Bool
$c== :: Overflow -> Overflow -> Bool
Eq)
instance P.Enum Overflow where
fromEnum :: Overflow -> Int
fromEnum Overflow
OverflowVisible = Int
0
fromEnum Overflow
OverflowHidden = Int
1
fromEnum (AnotherOverflow Int
k) = Int
k
toEnum :: Int -> Overflow
toEnum Int
0 = Overflow
OverflowVisible
toEnum Int
1 = Overflow
OverflowHidden
toEnum Int
k = Int -> Overflow
AnotherOverflow Int
k
instance P.Ord Overflow where
compare :: Overflow -> Overflow -> Ordering
compare Overflow
a Overflow
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (Overflow -> Int
forall a. Enum a => a -> Int
P.fromEnum Overflow
a) (Overflow -> Int
forall a. Enum a => a -> Int
P.fromEnum Overflow
b)
type instance O.ParentTypes Overflow = '[]
instance O.HasParentTypes Overflow
foreign import ccall "gtk_overflow_get_type" c_gtk_overflow_get_type ::
IO GType
instance B.Types.TypedObject Overflow where
glibType :: IO GType
glibType = IO GType
c_gtk_overflow_get_type
instance B.Types.BoxedEnum Overflow
data Orientation =
OrientationHorizontal
| OrientationVertical
| AnotherOrientation Int
deriving (Int -> Orientation -> ShowS
[Orientation] -> ShowS
Orientation -> String
(Int -> Orientation -> ShowS)
-> (Orientation -> String)
-> ([Orientation] -> ShowS)
-> Show Orientation
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Orientation] -> ShowS
$cshowList :: [Orientation] -> ShowS
show :: Orientation -> String
$cshow :: Orientation -> String
showsPrec :: Int -> Orientation -> ShowS
$cshowsPrec :: Int -> Orientation -> ShowS
Show, Orientation -> Orientation -> Bool
(Orientation -> Orientation -> Bool)
-> (Orientation -> Orientation -> Bool) -> Eq Orientation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Orientation -> Orientation -> Bool
$c/= :: Orientation -> Orientation -> Bool
== :: Orientation -> Orientation -> Bool
$c== :: Orientation -> Orientation -> Bool
Eq)
instance P.Enum Orientation where
fromEnum :: Orientation -> Int
fromEnum Orientation
OrientationHorizontal = Int
0
fromEnum Orientation
OrientationVertical = Int
1
fromEnum (AnotherOrientation Int
k) = Int
k
toEnum :: Int -> Orientation
toEnum Int
0 = Orientation
OrientationHorizontal
toEnum Int
1 = Orientation
OrientationVertical
toEnum Int
k = Int -> Orientation
AnotherOrientation Int
k
instance P.Ord Orientation where
compare :: Orientation -> Orientation -> Ordering
compare Orientation
a Orientation
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (Orientation -> Int
forall a. Enum a => a -> Int
P.fromEnum Orientation
a) (Orientation -> Int
forall a. Enum a => a -> Int
P.fromEnum Orientation
b)
type instance O.ParentTypes Orientation = '[]
instance O.HasParentTypes Orientation
foreign import ccall "gtk_orientation_get_type" c_gtk_orientation_get_type ::
IO GType
instance B.Types.TypedObject Orientation where
glibType :: IO GType
glibType = IO GType
c_gtk_orientation_get_type
instance B.Types.BoxedEnum Orientation
data Ordering =
OrderingSmaller
| OrderingEqual
| OrderingLarger
| AnotherOrdering Int
deriving (Int -> Ordering -> ShowS
[Ordering] -> ShowS
Ordering -> String
(Int -> Ordering -> ShowS)
-> (Ordering -> String) -> ([Ordering] -> ShowS) -> Show Ordering
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Ordering] -> ShowS
$cshowList :: [Ordering] -> ShowS
show :: Ordering -> String
$cshow :: Ordering -> String
showsPrec :: Int -> Ordering -> ShowS
$cshowsPrec :: Int -> Ordering -> ShowS
Show, Ordering -> Ordering -> Bool
(Ordering -> Ordering -> Bool)
-> (Ordering -> Ordering -> Bool) -> Eq Ordering
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Ordering -> Ordering -> Bool
$c/= :: Ordering -> Ordering -> Bool
== :: Ordering -> Ordering -> Bool
$c== :: Ordering -> Ordering -> Bool
Eq)
instance P.Enum Ordering where
fromEnum :: Ordering -> Int
fromEnum Ordering
OrderingSmaller = Int
-1
fromEnum Ordering
OrderingEqual = Int
0
fromEnum Ordering
OrderingLarger = Int
1
fromEnum (AnotherOrdering Int
k) = Int
k
toEnum :: Int -> Ordering
toEnum Int
-1 = Ordering
OrderingSmaller
toEnum Int
0 = Ordering
OrderingEqual
toEnum Int
1 = Ordering
OrderingLarger
toEnum Int
k = Int -> Ordering
AnotherOrdering Int
k
instance P.Ord Ordering where
compare :: Ordering -> Ordering -> Ordering
compare Ordering
a Ordering
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (Ordering -> Int
forall a. Enum a => a -> Int
P.fromEnum Ordering
a) (Ordering -> Int
forall a. Enum a => a -> Int
P.fromEnum Ordering
b)
type instance O.ParentTypes Ordering = '[]
instance O.HasParentTypes Ordering
foreign import ccall "gtk_ordering_get_type" c_gtk_ordering_get_type ::
IO GType
instance B.Types.TypedObject Ordering where
glibType :: IO GType
glibType = IO GType
c_gtk_ordering_get_type
instance B.Types.BoxedEnum Ordering
data NumberUpLayout =
NumberUpLayoutLrtb
| NumberUpLayoutLrbt
| NumberUpLayoutRltb
| NumberUpLayoutRlbt
| NumberUpLayoutTblr
| NumberUpLayoutTbrl
| NumberUpLayoutBtlr
| NumberUpLayoutBtrl
| AnotherNumberUpLayout Int
deriving (Int -> NumberUpLayout -> ShowS
[NumberUpLayout] -> ShowS
NumberUpLayout -> String
(Int -> NumberUpLayout -> ShowS)
-> (NumberUpLayout -> String)
-> ([NumberUpLayout] -> ShowS)
-> Show NumberUpLayout
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NumberUpLayout] -> ShowS
$cshowList :: [NumberUpLayout] -> ShowS
show :: NumberUpLayout -> String
$cshow :: NumberUpLayout -> String
showsPrec :: Int -> NumberUpLayout -> ShowS
$cshowsPrec :: Int -> NumberUpLayout -> ShowS
Show, NumberUpLayout -> NumberUpLayout -> Bool
(NumberUpLayout -> NumberUpLayout -> Bool)
-> (NumberUpLayout -> NumberUpLayout -> Bool) -> Eq NumberUpLayout
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NumberUpLayout -> NumberUpLayout -> Bool
$c/= :: NumberUpLayout -> NumberUpLayout -> Bool
== :: NumberUpLayout -> NumberUpLayout -> Bool
$c== :: NumberUpLayout -> NumberUpLayout -> Bool
Eq)
instance P.Enum NumberUpLayout where
fromEnum :: NumberUpLayout -> Int
fromEnum NumberUpLayout
NumberUpLayoutLrtb = Int
0
fromEnum NumberUpLayout
NumberUpLayoutLrbt = Int
1
fromEnum NumberUpLayout
NumberUpLayoutRltb = Int
2
fromEnum NumberUpLayout
NumberUpLayoutRlbt = Int
3
fromEnum NumberUpLayout
NumberUpLayoutTblr = Int
4
fromEnum NumberUpLayout
NumberUpLayoutTbrl = Int
5
fromEnum NumberUpLayout
NumberUpLayoutBtlr = Int
6
fromEnum NumberUpLayout
NumberUpLayoutBtrl = Int
7
fromEnum (AnotherNumberUpLayout Int
k) = Int
k
toEnum :: Int -> NumberUpLayout
toEnum Int
0 = NumberUpLayout
NumberUpLayoutLrtb
toEnum Int
1 = NumberUpLayout
NumberUpLayoutLrbt
toEnum Int
2 = NumberUpLayout
NumberUpLayoutRltb
toEnum Int
3 = NumberUpLayout
NumberUpLayoutRlbt
toEnum Int
4 = NumberUpLayout
NumberUpLayoutTblr
toEnum Int
5 = NumberUpLayout
NumberUpLayoutTbrl
toEnum Int
6 = NumberUpLayout
NumberUpLayoutBtlr
toEnum Int
7 = NumberUpLayout
NumberUpLayoutBtrl
toEnum Int
k = Int -> NumberUpLayout
AnotherNumberUpLayout Int
k
instance P.Ord NumberUpLayout where
compare :: NumberUpLayout -> NumberUpLayout -> Ordering
compare NumberUpLayout
a NumberUpLayout
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (NumberUpLayout -> Int
forall a. Enum a => a -> Int
P.fromEnum NumberUpLayout
a) (NumberUpLayout -> Int
forall a. Enum a => a -> Int
P.fromEnum NumberUpLayout
b)
type instance O.ParentTypes NumberUpLayout = '[]
instance O.HasParentTypes NumberUpLayout
foreign import ccall "gtk_number_up_layout_get_type" c_gtk_number_up_layout_get_type ::
IO GType
instance B.Types.TypedObject NumberUpLayout where
glibType :: IO GType
glibType = IO GType
c_gtk_number_up_layout_get_type
instance B.Types.BoxedEnum NumberUpLayout
data NotebookTab =
NotebookTabFirst
| NotebookTabLast
| AnotherNotebookTab Int
deriving (Int -> NotebookTab -> ShowS
[NotebookTab] -> ShowS
NotebookTab -> String
(Int -> NotebookTab -> ShowS)
-> (NotebookTab -> String)
-> ([NotebookTab] -> ShowS)
-> Show NotebookTab
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NotebookTab] -> ShowS
$cshowList :: [NotebookTab] -> ShowS
show :: NotebookTab -> String
$cshow :: NotebookTab -> String
showsPrec :: Int -> NotebookTab -> ShowS
$cshowsPrec :: Int -> NotebookTab -> ShowS
Show, NotebookTab -> NotebookTab -> Bool
(NotebookTab -> NotebookTab -> Bool)
-> (NotebookTab -> NotebookTab -> Bool) -> Eq NotebookTab
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NotebookTab -> NotebookTab -> Bool
$c/= :: NotebookTab -> NotebookTab -> Bool
== :: NotebookTab -> NotebookTab -> Bool
$c== :: NotebookTab -> NotebookTab -> Bool
Eq)
instance P.Enum NotebookTab where
fromEnum :: NotebookTab -> Int
fromEnum NotebookTab
NotebookTabFirst = Int
0
fromEnum NotebookTab
NotebookTabLast = Int
1
fromEnum (AnotherNotebookTab Int
k) = Int
k
toEnum :: Int -> NotebookTab
toEnum Int
0 = NotebookTab
NotebookTabFirst
toEnum Int
1 = NotebookTab
NotebookTabLast
toEnum Int
k = Int -> NotebookTab
AnotherNotebookTab Int
k
instance P.Ord NotebookTab where
compare :: NotebookTab -> NotebookTab -> Ordering
compare NotebookTab
a NotebookTab
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (NotebookTab -> Int
forall a. Enum a => a -> Int
P.fromEnum NotebookTab
a) (NotebookTab -> Int
forall a. Enum a => a -> Int
P.fromEnum NotebookTab
b)
type instance O.ParentTypes NotebookTab = '[]
instance O.HasParentTypes NotebookTab
foreign import ccall "gtk_notebook_tab_get_type" c_gtk_notebook_tab_get_type ::
IO GType
instance B.Types.TypedObject NotebookTab where
glibType :: IO GType
glibType = IO GType
c_gtk_notebook_tab_get_type
instance B.Types.BoxedEnum NotebookTab
data MovementStep =
MovementStepLogicalPositions
| MovementStepVisualPositions
| MovementStepWords
| MovementStepDisplayLines
| MovementStepDisplayLineEnds
| MovementStepParagraphs
| MovementStepParagraphEnds
| MovementStepPages
| MovementStepBufferEnds
| MovementStepHorizontalPages
| AnotherMovementStep Int
deriving (Int -> MovementStep -> ShowS
[MovementStep] -> ShowS
MovementStep -> String
(Int -> MovementStep -> ShowS)
-> (MovementStep -> String)
-> ([MovementStep] -> ShowS)
-> Show MovementStep
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MovementStep] -> ShowS
$cshowList :: [MovementStep] -> ShowS
show :: MovementStep -> String
$cshow :: MovementStep -> String
showsPrec :: Int -> MovementStep -> ShowS
$cshowsPrec :: Int -> MovementStep -> ShowS
Show, MovementStep -> MovementStep -> Bool
(MovementStep -> MovementStep -> Bool)
-> (MovementStep -> MovementStep -> Bool) -> Eq MovementStep
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MovementStep -> MovementStep -> Bool
$c/= :: MovementStep -> MovementStep -> Bool
== :: MovementStep -> MovementStep -> Bool
$c== :: MovementStep -> MovementStep -> Bool
Eq)
instance P.Enum MovementStep where
fromEnum :: MovementStep -> Int
fromEnum MovementStep
MovementStepLogicalPositions = Int
0
fromEnum MovementStep
MovementStepVisualPositions = Int
1
fromEnum MovementStep
MovementStepWords = Int
2
fromEnum MovementStep
MovementStepDisplayLines = Int
3
fromEnum MovementStep
MovementStepDisplayLineEnds = Int
4
fromEnum MovementStep
MovementStepParagraphs = Int
5
fromEnum MovementStep
MovementStepParagraphEnds = Int
6
fromEnum MovementStep
MovementStepPages = Int
7
fromEnum MovementStep
MovementStepBufferEnds = Int
8
fromEnum MovementStep
MovementStepHorizontalPages = Int
9
fromEnum (AnotherMovementStep Int
k) = Int
k
toEnum :: Int -> MovementStep
toEnum Int
0 = MovementStep
MovementStepLogicalPositions
toEnum Int
1 = MovementStep
MovementStepVisualPositions
toEnum Int
2 = MovementStep
MovementStepWords
toEnum Int
3 = MovementStep
MovementStepDisplayLines
toEnum Int
4 = MovementStep
MovementStepDisplayLineEnds
toEnum Int
5 = MovementStep
MovementStepParagraphs
toEnum Int
6 = MovementStep
MovementStepParagraphEnds
toEnum Int
7 = MovementStep
MovementStepPages
toEnum Int
8 = MovementStep
MovementStepBufferEnds
toEnum Int
9 = MovementStep
MovementStepHorizontalPages
toEnum Int
k = Int -> MovementStep
AnotherMovementStep Int
k
instance P.Ord MovementStep where
compare :: MovementStep -> MovementStep -> Ordering
compare MovementStep
a MovementStep
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (MovementStep -> Int
forall a. Enum a => a -> Int
P.fromEnum MovementStep
a) (MovementStep -> Int
forall a. Enum a => a -> Int
P.fromEnum MovementStep
b)
type instance O.ParentTypes MovementStep = '[]
instance O.HasParentTypes MovementStep
foreign import ccall "gtk_movement_step_get_type" c_gtk_movement_step_get_type ::
IO GType
instance B.Types.TypedObject MovementStep where
glibType :: IO GType
glibType = IO GType
c_gtk_movement_step_get_type
instance B.Types.BoxedEnum MovementStep
data MessageType =
MessageTypeInfo
| MessageTypeWarning
| MessageTypeQuestion
| MessageTypeError
| MessageTypeOther
| AnotherMessageType Int
deriving (Int -> MessageType -> ShowS
[MessageType] -> ShowS
MessageType -> String
(Int -> MessageType -> ShowS)
-> (MessageType -> String)
-> ([MessageType] -> ShowS)
-> Show MessageType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MessageType] -> ShowS
$cshowList :: [MessageType] -> ShowS
show :: MessageType -> String
$cshow :: MessageType -> String
showsPrec :: Int -> MessageType -> ShowS
$cshowsPrec :: Int -> MessageType -> ShowS
Show, MessageType -> MessageType -> Bool
(MessageType -> MessageType -> Bool)
-> (MessageType -> MessageType -> Bool) -> Eq MessageType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MessageType -> MessageType -> Bool
$c/= :: MessageType -> MessageType -> Bool
== :: MessageType -> MessageType -> Bool
$c== :: MessageType -> MessageType -> Bool
Eq)
instance P.Enum MessageType where
fromEnum :: MessageType -> Int
fromEnum MessageType
MessageTypeInfo = Int
0
fromEnum MessageType
MessageTypeWarning = Int
1
fromEnum MessageType
MessageTypeQuestion = Int
2
fromEnum MessageType
MessageTypeError = Int
3
fromEnum MessageType
MessageTypeOther = Int
4
fromEnum (AnotherMessageType Int
k) = Int
k
toEnum :: Int -> MessageType
toEnum Int
0 = MessageType
MessageTypeInfo
toEnum Int
1 = MessageType
MessageTypeWarning
toEnum Int
2 = MessageType
MessageTypeQuestion
toEnum Int
3 = MessageType
MessageTypeError
toEnum Int
4 = MessageType
MessageTypeOther
toEnum Int
k = Int -> MessageType
AnotherMessageType Int
k
instance P.Ord MessageType where
compare :: MessageType -> MessageType -> Ordering
compare MessageType
a MessageType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (MessageType -> Int
forall a. Enum a => a -> Int
P.fromEnum MessageType
a) (MessageType -> Int
forall a. Enum a => a -> Int
P.fromEnum MessageType
b)
type instance O.ParentTypes MessageType = '[]
instance O.HasParentTypes MessageType
foreign import ccall "gtk_message_type_get_type" c_gtk_message_type_get_type ::
IO GType
instance B.Types.TypedObject MessageType where
glibType :: IO GType
glibType = IO GType
c_gtk_message_type_get_type
instance B.Types.BoxedEnum MessageType
data License =
LicenseUnknown
| LicenseCustom
| LicenseGpl20
| LicenseGpl30
| LicenseLgpl21
| LicenseLgpl30
| LicenseBsd
| LicenseMitX11
| LicenseArtistic
| LicenseGpl20Only
| LicenseGpl30Only
| LicenseLgpl21Only
| LicenseLgpl30Only
| LicenseAgpl30
| LicenseAgpl30Only
| LicenseBsd3
| LicenseApache20
| LicenseMpl20
| AnotherLicense Int
deriving (Int -> License -> ShowS
[License] -> ShowS
License -> String
(Int -> License -> ShowS)
-> (License -> String) -> ([License] -> ShowS) -> Show License
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [License] -> ShowS
$cshowList :: [License] -> ShowS
show :: License -> String
$cshow :: License -> String
showsPrec :: Int -> License -> ShowS
$cshowsPrec :: Int -> License -> ShowS
Show, License -> License -> Bool
(License -> License -> Bool)
-> (License -> License -> Bool) -> Eq License
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: License -> License -> Bool
$c/= :: License -> License -> Bool
== :: License -> License -> Bool
$c== :: License -> License -> Bool
Eq)
instance P.Enum License where
fromEnum :: License -> Int
fromEnum License
LicenseUnknown = Int
0
fromEnum License
LicenseCustom = Int
1
fromEnum License
LicenseGpl20 = Int
2
fromEnum License
LicenseGpl30 = Int
3
fromEnum License
LicenseLgpl21 = Int
4
fromEnum License
LicenseLgpl30 = Int
5
fromEnum License
LicenseBsd = Int
6
fromEnum License
LicenseMitX11 = Int
7
fromEnum License
LicenseArtistic = Int
8
fromEnum License
LicenseGpl20Only = Int
9
fromEnum License
LicenseGpl30Only = Int
10
fromEnum License
LicenseLgpl21Only = Int
11
fromEnum License
LicenseLgpl30Only = Int
12
fromEnum License
LicenseAgpl30 = Int
13
fromEnum License
LicenseAgpl30Only = Int
14
fromEnum License
LicenseBsd3 = Int
15
fromEnum License
LicenseApache20 = Int
16
fromEnum License
LicenseMpl20 = Int
17
fromEnum (AnotherLicense Int
k) = Int
k
toEnum :: Int -> License
toEnum Int
0 = License
LicenseUnknown
toEnum Int
1 = License
LicenseCustom
toEnum Int
2 = License
LicenseGpl20
toEnum Int
3 = License
LicenseGpl30
toEnum Int
4 = License
LicenseLgpl21
toEnum Int
5 = License
LicenseLgpl30
toEnum Int
6 = License
LicenseBsd
toEnum Int
7 = License
LicenseMitX11
toEnum Int
8 = License
LicenseArtistic
toEnum Int
9 = License
LicenseGpl20Only
toEnum Int
10 = License
LicenseGpl30Only
toEnum Int
11 = License
LicenseLgpl21Only
toEnum Int
12 = License
LicenseLgpl30Only
toEnum Int
13 = License
LicenseAgpl30
toEnum Int
14 = License
LicenseAgpl30Only
toEnum Int
15 = License
LicenseBsd3
toEnum Int
16 = License
LicenseApache20
toEnum Int
17 = License
LicenseMpl20
toEnum Int
k = Int -> License
AnotherLicense Int
k
instance P.Ord License where
compare :: License -> License -> Ordering
compare License
a License
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (License -> Int
forall a. Enum a => a -> Int
P.fromEnum License
a) (License -> Int
forall a. Enum a => a -> Int
P.fromEnum License
b)
type instance O.ParentTypes License = '[]
instance O.HasParentTypes License
foreign import ccall "gtk_license_get_type" c_gtk_license_get_type ::
IO GType
instance B.Types.TypedObject License where
glibType :: IO GType
glibType = IO GType
c_gtk_license_get_type
instance B.Types.BoxedEnum License
data LevelBarMode =
LevelBarModeContinuous
| LevelBarModeDiscrete
| AnotherLevelBarMode Int
deriving (Int -> LevelBarMode -> ShowS
[LevelBarMode] -> ShowS
LevelBarMode -> String
(Int -> LevelBarMode -> ShowS)
-> (LevelBarMode -> String)
-> ([LevelBarMode] -> ShowS)
-> Show LevelBarMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [LevelBarMode] -> ShowS
$cshowList :: [LevelBarMode] -> ShowS
show :: LevelBarMode -> String
$cshow :: LevelBarMode -> String
showsPrec :: Int -> LevelBarMode -> ShowS
$cshowsPrec :: Int -> LevelBarMode -> ShowS
Show, LevelBarMode -> LevelBarMode -> Bool
(LevelBarMode -> LevelBarMode -> Bool)
-> (LevelBarMode -> LevelBarMode -> Bool) -> Eq LevelBarMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: LevelBarMode -> LevelBarMode -> Bool
$c/= :: LevelBarMode -> LevelBarMode -> Bool
== :: LevelBarMode -> LevelBarMode -> Bool
$c== :: LevelBarMode -> LevelBarMode -> Bool
Eq)
instance P.Enum LevelBarMode where
fromEnum :: LevelBarMode -> Int
fromEnum LevelBarMode
LevelBarModeContinuous = Int
0
fromEnum LevelBarMode
LevelBarModeDiscrete = Int
1
fromEnum (AnotherLevelBarMode Int
k) = Int
k
toEnum :: Int -> LevelBarMode
toEnum Int
0 = LevelBarMode
LevelBarModeContinuous
toEnum Int
1 = LevelBarMode
LevelBarModeDiscrete
toEnum Int
k = Int -> LevelBarMode
AnotherLevelBarMode Int
k
instance P.Ord LevelBarMode where
compare :: LevelBarMode -> LevelBarMode -> Ordering
compare LevelBarMode
a LevelBarMode
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (LevelBarMode -> Int
forall a. Enum a => a -> Int
P.fromEnum LevelBarMode
a) (LevelBarMode -> Int
forall a. Enum a => a -> Int
P.fromEnum LevelBarMode
b)
type instance O.ParentTypes LevelBarMode = '[]
instance O.HasParentTypes LevelBarMode
foreign import ccall "gtk_level_bar_mode_get_type" c_gtk_level_bar_mode_get_type ::
IO GType
instance B.Types.TypedObject LevelBarMode where
glibType :: IO GType
glibType = IO GType
c_gtk_level_bar_mode_get_type
instance B.Types.BoxedEnum LevelBarMode
data Justification =
JustificationLeft
| JustificationRight
| JustificationCenter
| JustificationFill
| AnotherJustification Int
deriving (Int -> Justification -> ShowS
[Justification] -> ShowS
Justification -> String
(Int -> Justification -> ShowS)
-> (Justification -> String)
-> ([Justification] -> ShowS)
-> Show Justification
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Justification] -> ShowS
$cshowList :: [Justification] -> ShowS
show :: Justification -> String
$cshow :: Justification -> String
showsPrec :: Int -> Justification -> ShowS
$cshowsPrec :: Int -> Justification -> ShowS
Show, Justification -> Justification -> Bool
(Justification -> Justification -> Bool)
-> (Justification -> Justification -> Bool) -> Eq Justification
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Justification -> Justification -> Bool
$c/= :: Justification -> Justification -> Bool
== :: Justification -> Justification -> Bool
$c== :: Justification -> Justification -> Bool
Eq)
instance P.Enum Justification where
fromEnum :: Justification -> Int
fromEnum Justification
JustificationLeft = Int
0
fromEnum Justification
JustificationRight = Int
1
fromEnum Justification
JustificationCenter = Int
2
fromEnum Justification
JustificationFill = Int
3
fromEnum (AnotherJustification Int
k) = Int
k
toEnum :: Int -> Justification
toEnum Int
0 = Justification
JustificationLeft
toEnum Int
1 = Justification
JustificationRight
toEnum Int
2 = Justification
JustificationCenter
toEnum Int
3 = Justification
JustificationFill
toEnum Int
k = Int -> Justification
AnotherJustification Int
k
instance P.Ord Justification where
compare :: Justification -> Justification -> Ordering
compare Justification
a Justification
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (Justification -> Int
forall a. Enum a => a -> Int
P.fromEnum Justification
a) (Justification -> Int
forall a. Enum a => a -> Int
P.fromEnum Justification
b)
type instance O.ParentTypes Justification = '[]
instance O.HasParentTypes Justification
foreign import ccall "gtk_justification_get_type" c_gtk_justification_get_type ::
IO GType
instance B.Types.TypedObject Justification where
glibType :: IO GType
glibType = IO GType
c_gtk_justification_get_type
instance B.Types.BoxedEnum Justification
data InputPurpose =
InputPurposeFreeForm
| InputPurposeAlpha
| InputPurposeDigits
| InputPurposeNumber
| InputPurposePhone
| InputPurposeUrl
| InputPurposeEmail
| InputPurposeName
| InputPurposePassword
| InputPurposePin
| InputPurposeTerminal
| AnotherInputPurpose Int
deriving (Int -> InputPurpose -> ShowS
[InputPurpose] -> ShowS
InputPurpose -> String
(Int -> InputPurpose -> ShowS)
-> (InputPurpose -> String)
-> ([InputPurpose] -> ShowS)
-> Show InputPurpose
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [InputPurpose] -> ShowS
$cshowList :: [InputPurpose] -> ShowS
show :: InputPurpose -> String
$cshow :: InputPurpose -> String
showsPrec :: Int -> InputPurpose -> ShowS
$cshowsPrec :: Int -> InputPurpose -> ShowS
Show, InputPurpose -> InputPurpose -> Bool
(InputPurpose -> InputPurpose -> Bool)
-> (InputPurpose -> InputPurpose -> Bool) -> Eq InputPurpose
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: InputPurpose -> InputPurpose -> Bool
$c/= :: InputPurpose -> InputPurpose -> Bool
== :: InputPurpose -> InputPurpose -> Bool
$c== :: InputPurpose -> InputPurpose -> Bool
Eq)
instance P.Enum InputPurpose where
fromEnum :: InputPurpose -> Int
fromEnum InputPurpose
InputPurposeFreeForm = Int
0
fromEnum InputPurpose
InputPurposeAlpha = Int
1
fromEnum InputPurpose
InputPurposeDigits = Int
2
fromEnum InputPurpose
InputPurposeNumber = Int
3
fromEnum InputPurpose
InputPurposePhone = Int
4
fromEnum InputPurpose
InputPurposeUrl = Int
5
fromEnum InputPurpose
InputPurposeEmail = Int
6
fromEnum InputPurpose
InputPurposeName = Int
7
fromEnum InputPurpose
InputPurposePassword = Int
8
fromEnum InputPurpose
InputPurposePin = Int
9
fromEnum InputPurpose
InputPurposeTerminal = Int
10
fromEnum (AnotherInputPurpose Int
k) = Int
k
toEnum :: Int -> InputPurpose
toEnum Int
0 = InputPurpose
InputPurposeFreeForm
toEnum Int
1 = InputPurpose
InputPurposeAlpha
toEnum Int
2 = InputPurpose
InputPurposeDigits
toEnum Int
3 = InputPurpose
InputPurposeNumber
toEnum Int
4 = InputPurpose
InputPurposePhone
toEnum Int
5 = InputPurpose
InputPurposeUrl
toEnum Int
6 = InputPurpose
InputPurposeEmail
toEnum Int
7 = InputPurpose
InputPurposeName
toEnum Int
8 = InputPurpose
InputPurposePassword
toEnum Int
9 = InputPurpose
InputPurposePin
toEnum Int
10 = InputPurpose
InputPurposeTerminal
toEnum Int
k = Int -> InputPurpose
AnotherInputPurpose Int
k
instance P.Ord InputPurpose where
compare :: InputPurpose -> InputPurpose -> Ordering
compare InputPurpose
a InputPurpose
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (InputPurpose -> Int
forall a. Enum a => a -> Int
P.fromEnum InputPurpose
a) (InputPurpose -> Int
forall a. Enum a => a -> Int
P.fromEnum InputPurpose
b)
type instance O.ParentTypes InputPurpose = '[]
instance O.HasParentTypes InputPurpose
foreign import ccall "gtk_input_purpose_get_type" c_gtk_input_purpose_get_type ::
IO GType
instance B.Types.TypedObject InputPurpose where
glibType :: IO GType
glibType = IO GType
c_gtk_input_purpose_get_type
instance B.Types.BoxedEnum InputPurpose
data ImageType =
ImageTypeEmpty
| ImageTypeIconName
| ImageTypeGicon
| ImageTypePaintable
| AnotherImageType Int
deriving (Int -> ImageType -> ShowS
[ImageType] -> ShowS
ImageType -> String
(Int -> ImageType -> ShowS)
-> (ImageType -> String)
-> ([ImageType] -> ShowS)
-> Show ImageType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ImageType] -> ShowS
$cshowList :: [ImageType] -> ShowS
show :: ImageType -> String
$cshow :: ImageType -> String
showsPrec :: Int -> ImageType -> ShowS
$cshowsPrec :: Int -> ImageType -> ShowS
Show, ImageType -> ImageType -> Bool
(ImageType -> ImageType -> Bool)
-> (ImageType -> ImageType -> Bool) -> Eq ImageType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ImageType -> ImageType -> Bool
$c/= :: ImageType -> ImageType -> Bool
== :: ImageType -> ImageType -> Bool
$c== :: ImageType -> ImageType -> Bool
Eq)
instance P.Enum ImageType where
fromEnum :: ImageType -> Int
fromEnum ImageType
ImageTypeEmpty = Int
0
fromEnum ImageType
ImageTypeIconName = Int
1
fromEnum ImageType
ImageTypeGicon = Int
2
fromEnum ImageType
ImageTypePaintable = Int
3
fromEnum (AnotherImageType Int
k) = Int
k
toEnum :: Int -> ImageType
toEnum Int
0 = ImageType
ImageTypeEmpty
toEnum Int
1 = ImageType
ImageTypeIconName
toEnum Int
2 = ImageType
ImageTypeGicon
toEnum Int
3 = ImageType
ImageTypePaintable
toEnum Int
k = Int -> ImageType
AnotherImageType Int
k
instance P.Ord ImageType where
compare :: ImageType -> ImageType -> Ordering
compare ImageType
a ImageType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ImageType -> Int
forall a. Enum a => a -> Int
P.fromEnum ImageType
a) (ImageType -> Int
forall a. Enum a => a -> Int
P.fromEnum ImageType
b)
type instance O.ParentTypes ImageType = '[]
instance O.HasParentTypes ImageType
foreign import ccall "gtk_image_type_get_type" c_gtk_image_type_get_type ::
IO GType
instance B.Types.TypedObject ImageType where
glibType :: IO GType
glibType = IO GType
c_gtk_image_type_get_type
instance B.Types.BoxedEnum ImageType
data IconViewDropPosition =
IconViewDropPositionNoDrop
| IconViewDropPositionDropInto
| IconViewDropPositionDropLeft
| IconViewDropPositionDropRight
| IconViewDropPositionDropAbove
| IconViewDropPositionDropBelow
| AnotherIconViewDropPosition Int
deriving (Int -> IconViewDropPosition -> ShowS
[IconViewDropPosition] -> ShowS
IconViewDropPosition -> String
(Int -> IconViewDropPosition -> ShowS)
-> (IconViewDropPosition -> String)
-> ([IconViewDropPosition] -> ShowS)
-> Show IconViewDropPosition
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [IconViewDropPosition] -> ShowS
$cshowList :: [IconViewDropPosition] -> ShowS
show :: IconViewDropPosition -> String
$cshow :: IconViewDropPosition -> String
showsPrec :: Int -> IconViewDropPosition -> ShowS
$cshowsPrec :: Int -> IconViewDropPosition -> ShowS
Show, IconViewDropPosition -> IconViewDropPosition -> Bool
(IconViewDropPosition -> IconViewDropPosition -> Bool)
-> (IconViewDropPosition -> IconViewDropPosition -> Bool)
-> Eq IconViewDropPosition
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: IconViewDropPosition -> IconViewDropPosition -> Bool
$c/= :: IconViewDropPosition -> IconViewDropPosition -> Bool
== :: IconViewDropPosition -> IconViewDropPosition -> Bool
$c== :: IconViewDropPosition -> IconViewDropPosition -> Bool
Eq)
instance P.Enum IconViewDropPosition where
fromEnum :: IconViewDropPosition -> Int
fromEnum IconViewDropPosition
IconViewDropPositionNoDrop = Int
0
fromEnum IconViewDropPosition
IconViewDropPositionDropInto = Int
1
fromEnum IconViewDropPosition
IconViewDropPositionDropLeft = Int
2
fromEnum IconViewDropPosition
IconViewDropPositionDropRight = Int
3
fromEnum IconViewDropPosition
IconViewDropPositionDropAbove = Int
4
fromEnum IconViewDropPosition
IconViewDropPositionDropBelow = Int
5
fromEnum (AnotherIconViewDropPosition Int
k) = Int
k
toEnum :: Int -> IconViewDropPosition
toEnum Int
0 = IconViewDropPosition
IconViewDropPositionNoDrop
toEnum Int
1 = IconViewDropPosition
IconViewDropPositionDropInto
toEnum Int
2 = IconViewDropPosition
IconViewDropPositionDropLeft
toEnum Int
3 = IconViewDropPosition
IconViewDropPositionDropRight
toEnum Int
4 = IconViewDropPosition
IconViewDropPositionDropAbove
toEnum Int
5 = IconViewDropPosition
IconViewDropPositionDropBelow
toEnum Int
k = Int -> IconViewDropPosition
AnotherIconViewDropPosition Int
k
instance P.Ord IconViewDropPosition where
compare :: IconViewDropPosition -> IconViewDropPosition -> Ordering
compare IconViewDropPosition
a IconViewDropPosition
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (IconViewDropPosition -> Int
forall a. Enum a => a -> Int
P.fromEnum IconViewDropPosition
a) (IconViewDropPosition -> Int
forall a. Enum a => a -> Int
P.fromEnum IconViewDropPosition
b)
type instance O.ParentTypes IconViewDropPosition = '[]
instance O.HasParentTypes IconViewDropPosition
foreign import ccall "gtk_icon_view_drop_position_get_type" c_gtk_icon_view_drop_position_get_type ::
IO GType
instance B.Types.TypedObject IconViewDropPosition where
glibType :: IO GType
glibType = IO GType
c_gtk_icon_view_drop_position_get_type
instance B.Types.BoxedEnum IconViewDropPosition
data IconThemeError =
IconThemeErrorNotFound
| IconThemeErrorFailed
| AnotherIconThemeError Int
deriving (Int -> IconThemeError -> ShowS
[IconThemeError] -> ShowS
IconThemeError -> String
(Int -> IconThemeError -> ShowS)
-> (IconThemeError -> String)
-> ([IconThemeError] -> ShowS)
-> Show IconThemeError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [IconThemeError] -> ShowS
$cshowList :: [IconThemeError] -> ShowS
show :: IconThemeError -> String
$cshow :: IconThemeError -> String
showsPrec :: Int -> IconThemeError -> ShowS
$cshowsPrec :: Int -> IconThemeError -> ShowS
Show, IconThemeError -> IconThemeError -> Bool
(IconThemeError -> IconThemeError -> Bool)
-> (IconThemeError -> IconThemeError -> Bool) -> Eq IconThemeError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: IconThemeError -> IconThemeError -> Bool
$c/= :: IconThemeError -> IconThemeError -> Bool
== :: IconThemeError -> IconThemeError -> Bool
$c== :: IconThemeError -> IconThemeError -> Bool
Eq)
instance P.Enum IconThemeError where
fromEnum :: IconThemeError -> Int
fromEnum IconThemeError
IconThemeErrorNotFound = Int
0
fromEnum IconThemeError
IconThemeErrorFailed = Int
1
fromEnum (AnotherIconThemeError Int
k) = Int
k
toEnum :: Int -> IconThemeError
toEnum Int
0 = IconThemeError
IconThemeErrorNotFound
toEnum Int
1 = IconThemeError
IconThemeErrorFailed
toEnum Int
k = Int -> IconThemeError
AnotherIconThemeError Int
k
instance P.Ord IconThemeError where
compare :: IconThemeError -> IconThemeError -> Ordering
compare IconThemeError
a IconThemeError
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (IconThemeError -> Int
forall a. Enum a => a -> Int
P.fromEnum IconThemeError
a) (IconThemeError -> Int
forall a. Enum a => a -> Int
P.fromEnum IconThemeError
b)
instance GErrorClass IconThemeError where
gerrorClassDomain :: IconThemeError -> Text
gerrorClassDomain IconThemeError
_ = Text
"gtk-icon-theme-error-quark"
catchIconThemeError ::
IO a ->
(IconThemeError -> GErrorMessage -> IO a) ->
IO a
catchIconThemeError :: forall a. IO a -> (IconThemeError -> Text -> IO a) -> IO a
catchIconThemeError = IO a -> (IconThemeError -> Text -> IO a) -> IO a
forall err a.
GErrorClass err =>
IO a -> (err -> Text -> IO a) -> IO a
catchGErrorJustDomain
handleIconThemeError ::
(IconThemeError -> GErrorMessage -> IO a) ->
IO a ->
IO a
handleIconThemeError :: forall a. (IconThemeError -> Text -> IO a) -> IO a -> IO a
handleIconThemeError = (IconThemeError -> Text -> IO a) -> IO a -> IO a
forall err a.
GErrorClass err =>
(err -> Text -> IO a) -> IO a -> IO a
handleGErrorJustDomain
type instance O.ParentTypes IconThemeError = '[]
instance O.HasParentTypes IconThemeError
foreign import ccall "gtk_icon_theme_error_get_type" c_gtk_icon_theme_error_get_type ::
IO GType
instance B.Types.TypedObject IconThemeError where
glibType :: IO GType
glibType = IO GType
c_gtk_icon_theme_error_get_type
instance B.Types.BoxedEnum IconThemeError
data IconSize =
IconSizeInherit
| IconSizeNormal
| IconSizeLarge
| AnotherIconSize Int
deriving (Int -> IconSize -> ShowS
[IconSize] -> ShowS
IconSize -> String
(Int -> IconSize -> ShowS)
-> (IconSize -> String) -> ([IconSize] -> ShowS) -> Show IconSize
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [IconSize] -> ShowS
$cshowList :: [IconSize] -> ShowS
show :: IconSize -> String
$cshow :: IconSize -> String
showsPrec :: Int -> IconSize -> ShowS
$cshowsPrec :: Int -> IconSize -> ShowS
Show, IconSize -> IconSize -> Bool
(IconSize -> IconSize -> Bool)
-> (IconSize -> IconSize -> Bool) -> Eq IconSize
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: IconSize -> IconSize -> Bool
$c/= :: IconSize -> IconSize -> Bool
== :: IconSize -> IconSize -> Bool
$c== :: IconSize -> IconSize -> Bool
Eq)
instance P.Enum IconSize where
fromEnum :: IconSize -> Int
fromEnum IconSize
IconSizeInherit = Int
0
fromEnum IconSize
IconSizeNormal = Int
1
fromEnum IconSize
IconSizeLarge = Int
2
fromEnum (AnotherIconSize Int
k) = Int
k
toEnum :: Int -> IconSize
toEnum Int
0 = IconSize
IconSizeInherit
toEnum Int
1 = IconSize
IconSizeNormal
toEnum Int
2 = IconSize
IconSizeLarge
toEnum Int
k = Int -> IconSize
AnotherIconSize Int
k
instance P.Ord IconSize where
compare :: IconSize -> IconSize -> Ordering
compare IconSize
a IconSize
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (IconSize -> Int
forall a. Enum a => a -> Int
P.fromEnum IconSize
a) (IconSize -> Int
forall a. Enum a => a -> Int
P.fromEnum IconSize
b)
type instance O.ParentTypes IconSize = '[]
instance O.HasParentTypes IconSize
foreign import ccall "gtk_icon_size_get_type" c_gtk_icon_size_get_type ::
IO GType
instance B.Types.TypedObject IconSize where
glibType :: IO GType
glibType = IO GType
c_gtk_icon_size_get_type
instance B.Types.BoxedEnum IconSize
data FilterMatch =
FilterMatchSome
| FilterMatchNone
| FilterMatchAll
| AnotherFilterMatch Int
deriving (Int -> FilterMatch -> ShowS
[FilterMatch] -> ShowS
FilterMatch -> String
(Int -> FilterMatch -> ShowS)
-> (FilterMatch -> String)
-> ([FilterMatch] -> ShowS)
-> Show FilterMatch
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FilterMatch] -> ShowS
$cshowList :: [FilterMatch] -> ShowS
show :: FilterMatch -> String
$cshow :: FilterMatch -> String
showsPrec :: Int -> FilterMatch -> ShowS
$cshowsPrec :: Int -> FilterMatch -> ShowS
Show, FilterMatch -> FilterMatch -> Bool
(FilterMatch -> FilterMatch -> Bool)
-> (FilterMatch -> FilterMatch -> Bool) -> Eq FilterMatch
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FilterMatch -> FilterMatch -> Bool
$c/= :: FilterMatch -> FilterMatch -> Bool
== :: FilterMatch -> FilterMatch -> Bool
$c== :: FilterMatch -> FilterMatch -> Bool
Eq)
instance P.Enum FilterMatch where
fromEnum :: FilterMatch -> Int
fromEnum FilterMatch
FilterMatchSome = Int
0
fromEnum FilterMatch
FilterMatchNone = Int
1
fromEnum FilterMatch
FilterMatchAll = Int
2
fromEnum (AnotherFilterMatch Int
k) = Int
k
toEnum :: Int -> FilterMatch
toEnum Int
0 = FilterMatch
FilterMatchSome
toEnum Int
1 = FilterMatch
FilterMatchNone
toEnum Int
2 = FilterMatch
FilterMatchAll
toEnum Int
k = Int -> FilterMatch
AnotherFilterMatch Int
k
instance P.Ord FilterMatch where
compare :: FilterMatch -> FilterMatch -> Ordering
compare FilterMatch
a FilterMatch
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (FilterMatch -> Int
forall a. Enum a => a -> Int
P.fromEnum FilterMatch
a) (FilterMatch -> Int
forall a. Enum a => a -> Int
P.fromEnum FilterMatch
b)
type instance O.ParentTypes FilterMatch = '[]
instance O.HasParentTypes FilterMatch
foreign import ccall "gtk_filter_match_get_type" c_gtk_filter_match_get_type ::
IO GType
instance B.Types.TypedObject FilterMatch where
glibType :: IO GType
glibType = IO GType
c_gtk_filter_match_get_type
instance B.Types.BoxedEnum FilterMatch
data FilterChange =
FilterChangeDifferent
| FilterChangeLessStrict
| FilterChangeMoreStrict
| AnotherFilterChange Int
deriving (Int -> FilterChange -> ShowS
[FilterChange] -> ShowS
FilterChange -> String
(Int -> FilterChange -> ShowS)
-> (FilterChange -> String)
-> ([FilterChange] -> ShowS)
-> Show FilterChange
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FilterChange] -> ShowS
$cshowList :: [FilterChange] -> ShowS
show :: FilterChange -> String
$cshow :: FilterChange -> String
showsPrec :: Int -> FilterChange -> ShowS
$cshowsPrec :: Int -> FilterChange -> ShowS
Show, FilterChange -> FilterChange -> Bool
(FilterChange -> FilterChange -> Bool)
-> (FilterChange -> FilterChange -> Bool) -> Eq FilterChange
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FilterChange -> FilterChange -> Bool
$c/= :: FilterChange -> FilterChange -> Bool
== :: FilterChange -> FilterChange -> Bool
$c== :: FilterChange -> FilterChange -> Bool
Eq)
instance P.Enum FilterChange where
fromEnum :: FilterChange -> Int
fromEnum FilterChange
FilterChangeDifferent = Int
0
fromEnum FilterChange
FilterChangeLessStrict = Int
1
fromEnum FilterChange
FilterChangeMoreStrict = Int
2
fromEnum (AnotherFilterChange Int
k) = Int
k
toEnum :: Int -> FilterChange
toEnum Int
0 = FilterChange
FilterChangeDifferent
toEnum Int
1 = FilterChange
FilterChangeLessStrict
toEnum Int
2 = FilterChange
FilterChangeMoreStrict
toEnum Int
k = Int -> FilterChange
AnotherFilterChange Int
k
instance P.Ord FilterChange where
compare :: FilterChange -> FilterChange -> Ordering
compare FilterChange
a FilterChange
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (FilterChange -> Int
forall a. Enum a => a -> Int
P.fromEnum FilterChange
a) (FilterChange -> Int
forall a. Enum a => a -> Int
P.fromEnum FilterChange
b)
type instance O.ParentTypes FilterChange = '[]
instance O.HasParentTypes FilterChange
foreign import ccall "gtk_filter_change_get_type" c_gtk_filter_change_get_type ::
IO GType
instance B.Types.TypedObject FilterChange where
glibType :: IO GType
glibType = IO GType
c_gtk_filter_change_get_type
instance B.Types.BoxedEnum FilterChange
data FileChooserError =
FileChooserErrorNonexistent
| FileChooserErrorBadFilename
| FileChooserErrorAlreadyExists
| FileChooserErrorIncompleteHostname
| AnotherFileChooserError Int
deriving (Int -> FileChooserError -> ShowS
[FileChooserError] -> ShowS
FileChooserError -> String
(Int -> FileChooserError -> ShowS)
-> (FileChooserError -> String)
-> ([FileChooserError] -> ShowS)
-> Show FileChooserError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FileChooserError] -> ShowS
$cshowList :: [FileChooserError] -> ShowS
show :: FileChooserError -> String
$cshow :: FileChooserError -> String
showsPrec :: Int -> FileChooserError -> ShowS
$cshowsPrec :: Int -> FileChooserError -> ShowS
Show, FileChooserError -> FileChooserError -> Bool
(FileChooserError -> FileChooserError -> Bool)
-> (FileChooserError -> FileChooserError -> Bool)
-> Eq FileChooserError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FileChooserError -> FileChooserError -> Bool
$c/= :: FileChooserError -> FileChooserError -> Bool
== :: FileChooserError -> FileChooserError -> Bool
$c== :: FileChooserError -> FileChooserError -> Bool
Eq)
instance P.Enum FileChooserError where
fromEnum :: FileChooserError -> Int
fromEnum FileChooserError
FileChooserErrorNonexistent = Int
0
fromEnum FileChooserError
FileChooserErrorBadFilename = Int
1
fromEnum FileChooserError
FileChooserErrorAlreadyExists = Int
2
fromEnum FileChooserError
FileChooserErrorIncompleteHostname = Int
3
fromEnum (AnotherFileChooserError Int
k) = Int
k
toEnum :: Int -> FileChooserError
toEnum Int
0 = FileChooserError
FileChooserErrorNonexistent
toEnum Int
1 = FileChooserError
FileChooserErrorBadFilename
toEnum Int
2 = FileChooserError
FileChooserErrorAlreadyExists
toEnum Int
3 = FileChooserError
FileChooserErrorIncompleteHostname
toEnum Int
k = Int -> FileChooserError
AnotherFileChooserError Int
k
instance P.Ord FileChooserError where
compare :: FileChooserError -> FileChooserError -> Ordering
compare FileChooserError
a FileChooserError
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (FileChooserError -> Int
forall a. Enum a => a -> Int
P.fromEnum FileChooserError
a) (FileChooserError -> Int
forall a. Enum a => a -> Int
P.fromEnum FileChooserError
b)
instance GErrorClass FileChooserError where
gerrorClassDomain :: FileChooserError -> Text
gerrorClassDomain FileChooserError
_ = Text
"gtk-file-chooser-error-quark"
catchFileChooserError ::
IO a ->
(FileChooserError -> GErrorMessage -> IO a) ->
IO a
catchFileChooserError :: forall a. IO a -> (FileChooserError -> Text -> IO a) -> IO a
catchFileChooserError = IO a -> (FileChooserError -> Text -> IO a) -> IO a
forall err a.
GErrorClass err =>
IO a -> (err -> Text -> IO a) -> IO a
catchGErrorJustDomain
handleFileChooserError ::
(FileChooserError -> GErrorMessage -> IO a) ->
IO a ->
IO a
handleFileChooserError :: forall a. (FileChooserError -> Text -> IO a) -> IO a -> IO a
handleFileChooserError = (FileChooserError -> Text -> IO a) -> IO a -> IO a
forall err a.
GErrorClass err =>
(err -> Text -> IO a) -> IO a -> IO a
handleGErrorJustDomain
type instance O.ParentTypes FileChooserError = '[]
instance O.HasParentTypes FileChooserError
foreign import ccall "gtk_file_chooser_error_get_type" c_gtk_file_chooser_error_get_type ::
IO GType
instance B.Types.TypedObject FileChooserError where
glibType :: IO GType
glibType = IO GType
c_gtk_file_chooser_error_get_type
instance B.Types.BoxedEnum FileChooserError
data FileChooserAction =
FileChooserActionOpen
| FileChooserActionSave
| FileChooserActionSelectFolder
| AnotherFileChooserAction Int
deriving (Int -> FileChooserAction -> ShowS
[FileChooserAction] -> ShowS
FileChooserAction -> String
(Int -> FileChooserAction -> ShowS)
-> (FileChooserAction -> String)
-> ([FileChooserAction] -> ShowS)
-> Show FileChooserAction
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FileChooserAction] -> ShowS
$cshowList :: [FileChooserAction] -> ShowS
show :: FileChooserAction -> String
$cshow :: FileChooserAction -> String
showsPrec :: Int -> FileChooserAction -> ShowS
$cshowsPrec :: Int -> FileChooserAction -> ShowS
Show, FileChooserAction -> FileChooserAction -> Bool
(FileChooserAction -> FileChooserAction -> Bool)
-> (FileChooserAction -> FileChooserAction -> Bool)
-> Eq FileChooserAction
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FileChooserAction -> FileChooserAction -> Bool
$c/= :: FileChooserAction -> FileChooserAction -> Bool
== :: FileChooserAction -> FileChooserAction -> Bool
$c== :: FileChooserAction -> FileChooserAction -> Bool
Eq)
instance P.Enum FileChooserAction where
fromEnum :: FileChooserAction -> Int
fromEnum FileChooserAction
FileChooserActionOpen = Int
0
fromEnum FileChooserAction
FileChooserActionSave = Int
1
fromEnum FileChooserAction
FileChooserActionSelectFolder = Int
2
fromEnum (AnotherFileChooserAction Int
k) = Int
k
toEnum :: Int -> FileChooserAction
toEnum Int
0 = FileChooserAction
FileChooserActionOpen
toEnum Int
1 = FileChooserAction
FileChooserActionSave
toEnum Int
2 = FileChooserAction
FileChooserActionSelectFolder
toEnum Int
k = Int -> FileChooserAction
AnotherFileChooserAction Int
k
instance P.Ord FileChooserAction where
compare :: FileChooserAction -> FileChooserAction -> Ordering
compare FileChooserAction
a FileChooserAction
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (FileChooserAction -> Int
forall a. Enum a => a -> Int
P.fromEnum FileChooserAction
a) (FileChooserAction -> Int
forall a. Enum a => a -> Int
P.fromEnum FileChooserAction
b)
type instance O.ParentTypes FileChooserAction = '[]
instance O.HasParentTypes FileChooserAction
foreign import ccall "gtk_file_chooser_action_get_type" c_gtk_file_chooser_action_get_type ::
IO GType
instance B.Types.TypedObject FileChooserAction where
glibType :: IO GType
glibType = IO GType
c_gtk_file_chooser_action_get_type
instance B.Types.BoxedEnum FileChooserAction
data EventSequenceState =
EventSequenceStateNone
| EventSequenceStateClaimed
| EventSequenceStateDenied
| AnotherEventSequenceState Int
deriving (Int -> EventSequenceState -> ShowS
[EventSequenceState] -> ShowS
EventSequenceState -> String
(Int -> EventSequenceState -> ShowS)
-> (EventSequenceState -> String)
-> ([EventSequenceState] -> ShowS)
-> Show EventSequenceState
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [EventSequenceState] -> ShowS
$cshowList :: [EventSequenceState] -> ShowS
show :: EventSequenceState -> String
$cshow :: EventSequenceState -> String
showsPrec :: Int -> EventSequenceState -> ShowS
$cshowsPrec :: Int -> EventSequenceState -> ShowS
Show, EventSequenceState -> EventSequenceState -> Bool
(EventSequenceState -> EventSequenceState -> Bool)
-> (EventSequenceState -> EventSequenceState -> Bool)
-> Eq EventSequenceState
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: EventSequenceState -> EventSequenceState -> Bool
$c/= :: EventSequenceState -> EventSequenceState -> Bool
== :: EventSequenceState -> EventSequenceState -> Bool
$c== :: EventSequenceState -> EventSequenceState -> Bool
Eq)
instance P.Enum EventSequenceState where
fromEnum :: EventSequenceState -> Int
fromEnum EventSequenceState
EventSequenceStateNone = Int
0
fromEnum EventSequenceState
EventSequenceStateClaimed = Int
1
fromEnum EventSequenceState
EventSequenceStateDenied = Int
2
fromEnum (AnotherEventSequenceState Int
k) = Int
k
toEnum :: Int -> EventSequenceState
toEnum Int
0 = EventSequenceState
EventSequenceStateNone
toEnum Int
1 = EventSequenceState
EventSequenceStateClaimed
toEnum Int
2 = EventSequenceState
EventSequenceStateDenied
toEnum Int
k = Int -> EventSequenceState
AnotherEventSequenceState Int
k
instance P.Ord EventSequenceState where
compare :: EventSequenceState -> EventSequenceState -> Ordering
compare EventSequenceState
a EventSequenceState
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (EventSequenceState -> Int
forall a. Enum a => a -> Int
P.fromEnum EventSequenceState
a) (EventSequenceState -> Int
forall a. Enum a => a -> Int
P.fromEnum EventSequenceState
b)
type instance O.ParentTypes EventSequenceState = '[]
instance O.HasParentTypes EventSequenceState
foreign import ccall "gtk_event_sequence_state_get_type" c_gtk_event_sequence_state_get_type ::
IO GType
instance B.Types.TypedObject EventSequenceState where
glibType :: IO GType
glibType = IO GType
c_gtk_event_sequence_state_get_type
instance B.Types.BoxedEnum EventSequenceState
data EntryIconPosition =
EntryIconPositionPrimary
| EntryIconPositionSecondary
| AnotherEntryIconPosition Int
deriving (Int -> EntryIconPosition -> ShowS
[EntryIconPosition] -> ShowS
EntryIconPosition -> String
(Int -> EntryIconPosition -> ShowS)
-> (EntryIconPosition -> String)
-> ([EntryIconPosition] -> ShowS)
-> Show EntryIconPosition
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [EntryIconPosition] -> ShowS
$cshowList :: [EntryIconPosition] -> ShowS
show :: EntryIconPosition -> String
$cshow :: EntryIconPosition -> String
showsPrec :: Int -> EntryIconPosition -> ShowS
$cshowsPrec :: Int -> EntryIconPosition -> ShowS
Show, EntryIconPosition -> EntryIconPosition -> Bool
(EntryIconPosition -> EntryIconPosition -> Bool)
-> (EntryIconPosition -> EntryIconPosition -> Bool)
-> Eq EntryIconPosition
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: EntryIconPosition -> EntryIconPosition -> Bool
$c/= :: EntryIconPosition -> EntryIconPosition -> Bool
== :: EntryIconPosition -> EntryIconPosition -> Bool
$c== :: EntryIconPosition -> EntryIconPosition -> Bool
Eq)
instance P.Enum EntryIconPosition where
fromEnum :: EntryIconPosition -> Int
fromEnum EntryIconPosition
EntryIconPositionPrimary = Int
0
fromEnum EntryIconPosition
EntryIconPositionSecondary = Int
1
fromEnum (AnotherEntryIconPosition Int
k) = Int
k
toEnum :: Int -> EntryIconPosition
toEnum Int
0 = EntryIconPosition
EntryIconPositionPrimary
toEnum Int
1 = EntryIconPosition
EntryIconPositionSecondary
toEnum Int
k = Int -> EntryIconPosition
AnotherEntryIconPosition Int
k
instance P.Ord EntryIconPosition where
compare :: EntryIconPosition -> EntryIconPosition -> Ordering
compare EntryIconPosition
a EntryIconPosition
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (EntryIconPosition -> Int
forall a. Enum a => a -> Int
P.fromEnum EntryIconPosition
a) (EntryIconPosition -> Int
forall a. Enum a => a -> Int
P.fromEnum EntryIconPosition
b)
type instance O.ParentTypes EntryIconPosition = '[]
instance O.HasParentTypes EntryIconPosition
foreign import ccall "gtk_entry_icon_position_get_type" c_gtk_entry_icon_position_get_type ::
IO GType
instance B.Types.TypedObject EntryIconPosition where
glibType :: IO GType
glibType = IO GType
c_gtk_entry_icon_position_get_type
instance B.Types.BoxedEnum EntryIconPosition
data EditableProperties =
EditablePropertiesPropText
| EditablePropertiesPropCursorPosition
| EditablePropertiesPropSelectionBound
| EditablePropertiesPropEditable
| EditablePropertiesPropWidthChars
| EditablePropertiesPropMaxWidthChars
| EditablePropertiesPropXalign
| EditablePropertiesPropEnableUndo
| EditablePropertiesNumProperties
| AnotherEditableProperties Int
deriving (Int -> EditableProperties -> ShowS
[EditableProperties] -> ShowS
EditableProperties -> String
(Int -> EditableProperties -> ShowS)
-> (EditableProperties -> String)
-> ([EditableProperties] -> ShowS)
-> Show EditableProperties
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [EditableProperties] -> ShowS
$cshowList :: [EditableProperties] -> ShowS
show :: EditableProperties -> String
$cshow :: EditableProperties -> String
showsPrec :: Int -> EditableProperties -> ShowS
$cshowsPrec :: Int -> EditableProperties -> ShowS
Show, EditableProperties -> EditableProperties -> Bool
(EditableProperties -> EditableProperties -> Bool)
-> (EditableProperties -> EditableProperties -> Bool)
-> Eq EditableProperties
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: EditableProperties -> EditableProperties -> Bool
$c/= :: EditableProperties -> EditableProperties -> Bool
== :: EditableProperties -> EditableProperties -> Bool
$c== :: EditableProperties -> EditableProperties -> Bool
Eq)
instance P.Enum EditableProperties where
fromEnum :: EditableProperties -> Int
fromEnum EditableProperties
EditablePropertiesPropText = Int
0
fromEnum EditableProperties
EditablePropertiesPropCursorPosition = Int
1
fromEnum EditableProperties
EditablePropertiesPropSelectionBound = Int
2
fromEnum EditableProperties
EditablePropertiesPropEditable = Int
3
fromEnum EditableProperties
EditablePropertiesPropWidthChars = Int
4
fromEnum EditableProperties
EditablePropertiesPropMaxWidthChars = Int
5
fromEnum EditableProperties
EditablePropertiesPropXalign = Int
6
fromEnum EditableProperties
EditablePropertiesPropEnableUndo = Int
7
fromEnum EditableProperties
EditablePropertiesNumProperties = Int
8
fromEnum (AnotherEditableProperties Int
k) = Int
k
toEnum :: Int -> EditableProperties
toEnum Int
0 = EditableProperties
EditablePropertiesPropText
toEnum Int
1 = EditableProperties
EditablePropertiesPropCursorPosition
toEnum Int
2 = EditableProperties
EditablePropertiesPropSelectionBound
toEnum Int
3 = EditableProperties
EditablePropertiesPropEditable
toEnum Int
4 = EditableProperties
EditablePropertiesPropWidthChars
toEnum Int
5 = EditableProperties
EditablePropertiesPropMaxWidthChars
toEnum Int
6 = EditableProperties
EditablePropertiesPropXalign
toEnum Int
7 = EditableProperties
EditablePropertiesPropEnableUndo
toEnum Int
8 = EditableProperties
EditablePropertiesNumProperties
toEnum Int
k = Int -> EditableProperties
AnotherEditableProperties Int
k
instance P.Ord EditableProperties where
compare :: EditableProperties -> EditableProperties -> Ordering
compare EditableProperties
a EditableProperties
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (EditableProperties -> Int
forall a. Enum a => a -> Int
P.fromEnum EditableProperties
a) (EditableProperties -> Int
forall a. Enum a => a -> Int
P.fromEnum EditableProperties
b)
type instance O.ParentTypes EditableProperties = '[]
instance O.HasParentTypes EditableProperties
foreign import ccall "gtk_editable_properties_get_type" c_gtk_editable_properties_get_type ::
IO GType
instance B.Types.TypedObject EditableProperties where
glibType :: IO GType
glibType = IO GType
c_gtk_editable_properties_get_type
instance B.Types.BoxedEnum EditableProperties
data DirectionType =
DirectionTypeTabForward
| DirectionTypeTabBackward
| DirectionTypeUp
| DirectionTypeDown
| DirectionTypeLeft
| DirectionTypeRight
| AnotherDirectionType Int
deriving (Int -> DirectionType -> ShowS
[DirectionType] -> ShowS
DirectionType -> String
(Int -> DirectionType -> ShowS)
-> (DirectionType -> String)
-> ([DirectionType] -> ShowS)
-> Show DirectionType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DirectionType] -> ShowS
$cshowList :: [DirectionType] -> ShowS
show :: DirectionType -> String
$cshow :: DirectionType -> String
showsPrec :: Int -> DirectionType -> ShowS
$cshowsPrec :: Int -> DirectionType -> ShowS
Show, DirectionType -> DirectionType -> Bool
(DirectionType -> DirectionType -> Bool)
-> (DirectionType -> DirectionType -> Bool) -> Eq DirectionType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DirectionType -> DirectionType -> Bool
$c/= :: DirectionType -> DirectionType -> Bool
== :: DirectionType -> DirectionType -> Bool
$c== :: DirectionType -> DirectionType -> Bool
Eq)
instance P.Enum DirectionType where
fromEnum :: DirectionType -> Int
fromEnum DirectionType
DirectionTypeTabForward = Int
0
fromEnum DirectionType
DirectionTypeTabBackward = Int
1
fromEnum DirectionType
DirectionTypeUp = Int
2
fromEnum DirectionType
DirectionTypeDown = Int
3
fromEnum DirectionType
DirectionTypeLeft = Int
4
fromEnum DirectionType
DirectionTypeRight = Int
5
fromEnum (AnotherDirectionType Int
k) = Int
k
toEnum :: Int -> DirectionType
toEnum Int
0 = DirectionType
DirectionTypeTabForward
toEnum Int
1 = DirectionType
DirectionTypeTabBackward
toEnum Int
2 = DirectionType
DirectionTypeUp
toEnum Int
3 = DirectionType
DirectionTypeDown
toEnum Int
4 = DirectionType
DirectionTypeLeft
toEnum Int
5 = DirectionType
DirectionTypeRight
toEnum Int
k = Int -> DirectionType
AnotherDirectionType Int
k
instance P.Ord DirectionType where
compare :: DirectionType -> DirectionType -> Ordering
compare DirectionType
a DirectionType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (DirectionType -> Int
forall a. Enum a => a -> Int
P.fromEnum DirectionType
a) (DirectionType -> Int
forall a. Enum a => a -> Int
P.fromEnum DirectionType
b)
type instance O.ParentTypes DirectionType = '[]
instance O.HasParentTypes DirectionType
foreign import ccall "gtk_direction_type_get_type" c_gtk_direction_type_get_type ::
IO GType
instance B.Types.TypedObject DirectionType where
glibType :: IO GType
glibType = IO GType
c_gtk_direction_type_get_type
instance B.Types.BoxedEnum DirectionType
data DeleteType =
DeleteTypeChars
| DeleteTypeWordEnds
| DeleteTypeWords
| DeleteTypeDisplayLines
| DeleteTypeDisplayLineEnds
| DeleteTypeParagraphEnds
| DeleteTypeParagraphs
| DeleteTypeWhitespace
| AnotherDeleteType Int
deriving (Int -> DeleteType -> ShowS
[DeleteType] -> ShowS
DeleteType -> String
(Int -> DeleteType -> ShowS)
-> (DeleteType -> String)
-> ([DeleteType] -> ShowS)
-> Show DeleteType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DeleteType] -> ShowS
$cshowList :: [DeleteType] -> ShowS
show :: DeleteType -> String
$cshow :: DeleteType -> String
showsPrec :: Int -> DeleteType -> ShowS
$cshowsPrec :: Int -> DeleteType -> ShowS
Show, DeleteType -> DeleteType -> Bool
(DeleteType -> DeleteType -> Bool)
-> (DeleteType -> DeleteType -> Bool) -> Eq DeleteType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DeleteType -> DeleteType -> Bool
$c/= :: DeleteType -> DeleteType -> Bool
== :: DeleteType -> DeleteType -> Bool
$c== :: DeleteType -> DeleteType -> Bool
Eq)
instance P.Enum DeleteType where
fromEnum :: DeleteType -> Int
fromEnum DeleteType
DeleteTypeChars = Int
0
fromEnum DeleteType
DeleteTypeWordEnds = Int
1
fromEnum DeleteType
DeleteTypeWords = Int
2
fromEnum DeleteType
DeleteTypeDisplayLines = Int
3
fromEnum DeleteType
DeleteTypeDisplayLineEnds = Int
4
fromEnum DeleteType
DeleteTypeParagraphEnds = Int
5
fromEnum DeleteType
DeleteTypeParagraphs = Int
6
fromEnum DeleteType
DeleteTypeWhitespace = Int
7
fromEnum (AnotherDeleteType Int
k) = Int
k
toEnum :: Int -> DeleteType
toEnum Int
0 = DeleteType
DeleteTypeChars
toEnum Int
1 = DeleteType
DeleteTypeWordEnds
toEnum Int
2 = DeleteType
DeleteTypeWords
toEnum Int
3 = DeleteType
DeleteTypeDisplayLines
toEnum Int
4 = DeleteType
DeleteTypeDisplayLineEnds
toEnum Int
5 = DeleteType
DeleteTypeParagraphEnds
toEnum Int
6 = DeleteType
DeleteTypeParagraphs
toEnum Int
7 = DeleteType
DeleteTypeWhitespace
toEnum Int
k = Int -> DeleteType
AnotherDeleteType Int
k
instance P.Ord DeleteType where
compare :: DeleteType -> DeleteType -> Ordering
compare DeleteType
a DeleteType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (DeleteType -> Int
forall a. Enum a => a -> Int
P.fromEnum DeleteType
a) (DeleteType -> Int
forall a. Enum a => a -> Int
P.fromEnum DeleteType
b)
type instance O.ParentTypes DeleteType = '[]
instance O.HasParentTypes DeleteType
foreign import ccall "gtk_delete_type_get_type" c_gtk_delete_type_get_type ::
IO GType
instance B.Types.TypedObject DeleteType where
glibType :: IO GType
glibType = IO GType
c_gtk_delete_type_get_type
instance B.Types.BoxedEnum DeleteType
data CssParserWarning =
CssParserWarningDeprecated
| CssParserWarningSyntax
| CssParserWarningUnimplemented
| AnotherCssParserWarning Int
deriving (Int -> CssParserWarning -> ShowS
[CssParserWarning] -> ShowS
CssParserWarning -> String
(Int -> CssParserWarning -> ShowS)
-> (CssParserWarning -> String)
-> ([CssParserWarning] -> ShowS)
-> Show CssParserWarning
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CssParserWarning] -> ShowS
$cshowList :: [CssParserWarning] -> ShowS
show :: CssParserWarning -> String
$cshow :: CssParserWarning -> String
showsPrec :: Int -> CssParserWarning -> ShowS
$cshowsPrec :: Int -> CssParserWarning -> ShowS
Show, CssParserWarning -> CssParserWarning -> Bool
(CssParserWarning -> CssParserWarning -> Bool)
-> (CssParserWarning -> CssParserWarning -> Bool)
-> Eq CssParserWarning
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CssParserWarning -> CssParserWarning -> Bool
$c/= :: CssParserWarning -> CssParserWarning -> Bool
== :: CssParserWarning -> CssParserWarning -> Bool
$c== :: CssParserWarning -> CssParserWarning -> Bool
Eq)
instance P.Enum CssParserWarning where
fromEnum :: CssParserWarning -> Int
fromEnum CssParserWarning
CssParserWarningDeprecated = Int
0
fromEnum CssParserWarning
CssParserWarningSyntax = Int
1
fromEnum CssParserWarning
CssParserWarningUnimplemented = Int
2
fromEnum (AnotherCssParserWarning Int
k) = Int
k
toEnum :: Int -> CssParserWarning
toEnum Int
0 = CssParserWarning
CssParserWarningDeprecated
toEnum Int
1 = CssParserWarning
CssParserWarningSyntax
toEnum Int
2 = CssParserWarning
CssParserWarningUnimplemented
toEnum Int
k = Int -> CssParserWarning
AnotherCssParserWarning Int
k
instance P.Ord CssParserWarning where
compare :: CssParserWarning -> CssParserWarning -> Ordering
compare CssParserWarning
a CssParserWarning
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (CssParserWarning -> Int
forall a. Enum a => a -> Int
P.fromEnum CssParserWarning
a) (CssParserWarning -> Int
forall a. Enum a => a -> Int
P.fromEnum CssParserWarning
b)
data CssParserError =
CssParserErrorFailed
| CssParserErrorSyntax
| CssParserErrorImport
| CssParserErrorName
| CssParserErrorUnknownValue
| AnotherCssParserError Int
deriving (Int -> CssParserError -> ShowS
[CssParserError] -> ShowS
CssParserError -> String
(Int -> CssParserError -> ShowS)
-> (CssParserError -> String)
-> ([CssParserError] -> ShowS)
-> Show CssParserError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CssParserError] -> ShowS
$cshowList :: [CssParserError] -> ShowS
show :: CssParserError -> String
$cshow :: CssParserError -> String
showsPrec :: Int -> CssParserError -> ShowS
$cshowsPrec :: Int -> CssParserError -> ShowS
Show, CssParserError -> CssParserError -> Bool
(CssParserError -> CssParserError -> Bool)
-> (CssParserError -> CssParserError -> Bool) -> Eq CssParserError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CssParserError -> CssParserError -> Bool
$c/= :: CssParserError -> CssParserError -> Bool
== :: CssParserError -> CssParserError -> Bool
$c== :: CssParserError -> CssParserError -> Bool
Eq)
instance P.Enum CssParserError where
fromEnum :: CssParserError -> Int
fromEnum CssParserError
CssParserErrorFailed = Int
0
fromEnum CssParserError
CssParserErrorSyntax = Int
1
fromEnum CssParserError
CssParserErrorImport = Int
2
fromEnum CssParserError
CssParserErrorName = Int
3
fromEnum CssParserError
CssParserErrorUnknownValue = Int
4
fromEnum (AnotherCssParserError Int
k) = Int
k
toEnum :: Int -> CssParserError
toEnum Int
0 = CssParserError
CssParserErrorFailed
toEnum Int
1 = CssParserError
CssParserErrorSyntax
toEnum Int
2 = CssParserError
CssParserErrorImport
toEnum Int
3 = CssParserError
CssParserErrorName
toEnum Int
4 = CssParserError
CssParserErrorUnknownValue
toEnum Int
k = Int -> CssParserError
AnotherCssParserError Int
k
instance P.Ord CssParserError where
compare :: CssParserError -> CssParserError -> Ordering
compare CssParserError
a CssParserError
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (CssParserError -> Int
forall a. Enum a => a -> Int
P.fromEnum CssParserError
a) (CssParserError -> Int
forall a. Enum a => a -> Int
P.fromEnum CssParserError
b)
instance GErrorClass CssParserError where
gerrorClassDomain :: CssParserError -> Text
gerrorClassDomain CssParserError
_ = Text
"gtk-css-parser-error-quark"
catchCssParserError ::
IO a ->
(CssParserError -> GErrorMessage -> IO a) ->
IO a
catchCssParserError :: forall a. IO a -> (CssParserError -> Text -> IO a) -> IO a
catchCssParserError = IO a -> (CssParserError -> Text -> IO a) -> IO a
forall err a.
GErrorClass err =>
IO a -> (err -> Text -> IO a) -> IO a
catchGErrorJustDomain
handleCssParserError ::
(CssParserError -> GErrorMessage -> IO a) ->
IO a ->
IO a
handleCssParserError :: forall a. (CssParserError -> Text -> IO a) -> IO a -> IO a
handleCssParserError = (CssParserError -> Text -> IO a) -> IO a -> IO a
forall err a.
GErrorClass err =>
(err -> Text -> IO a) -> IO a -> IO a
handleGErrorJustDomain
data CornerType =
CornerTypeTopLeft
| CornerTypeBottomLeft
| CornerTypeTopRight
| CornerTypeBottomRight
| AnotherCornerType Int
deriving (Int -> CornerType -> ShowS
[CornerType] -> ShowS
CornerType -> String
(Int -> CornerType -> ShowS)
-> (CornerType -> String)
-> ([CornerType] -> ShowS)
-> Show CornerType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CornerType] -> ShowS
$cshowList :: [CornerType] -> ShowS
show :: CornerType -> String
$cshow :: CornerType -> String
showsPrec :: Int -> CornerType -> ShowS
$cshowsPrec :: Int -> CornerType -> ShowS
Show, CornerType -> CornerType -> Bool
(CornerType -> CornerType -> Bool)
-> (CornerType -> CornerType -> Bool) -> Eq CornerType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CornerType -> CornerType -> Bool
$c/= :: CornerType -> CornerType -> Bool
== :: CornerType -> CornerType -> Bool
$c== :: CornerType -> CornerType -> Bool
Eq)
instance P.Enum CornerType where
fromEnum :: CornerType -> Int
fromEnum CornerType
CornerTypeTopLeft = Int
0
fromEnum CornerType
CornerTypeBottomLeft = Int
1
fromEnum CornerType
CornerTypeTopRight = Int
2
fromEnum CornerType
CornerTypeBottomRight = Int
3
fromEnum (AnotherCornerType Int
k) = Int
k
toEnum :: Int -> CornerType
toEnum Int
0 = CornerType
CornerTypeTopLeft
toEnum Int
1 = CornerType
CornerTypeBottomLeft
toEnum Int
2 = CornerType
CornerTypeTopRight
toEnum Int
3 = CornerType
CornerTypeBottomRight
toEnum Int
k = Int -> CornerType
AnotherCornerType Int
k
instance P.Ord CornerType where
compare :: CornerType -> CornerType -> Ordering
compare CornerType
a CornerType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (CornerType -> Int
forall a. Enum a => a -> Int
P.fromEnum CornerType
a) (CornerType -> Int
forall a. Enum a => a -> Int
P.fromEnum CornerType
b)
type instance O.ParentTypes CornerType = '[]
instance O.HasParentTypes CornerType
foreign import ccall "gtk_corner_type_get_type" c_gtk_corner_type_get_type ::
IO GType
instance B.Types.TypedObject CornerType where
glibType :: IO GType
glibType = IO GType
c_gtk_corner_type_get_type
instance B.Types.BoxedEnum CornerType
data ConstraintVflParserError =
ConstraintVflParserErrorSymbol
| ConstraintVflParserErrorAttribute
| ConstraintVflParserErrorView
| ConstraintVflParserErrorMetric
| ConstraintVflParserErrorPriority
| ConstraintVflParserErrorRelation
| AnotherConstraintVflParserError Int
deriving (Int -> ConstraintVflParserError -> ShowS
[ConstraintVflParserError] -> ShowS
ConstraintVflParserError -> String
(Int -> ConstraintVflParserError -> ShowS)
-> (ConstraintVflParserError -> String)
-> ([ConstraintVflParserError] -> ShowS)
-> Show ConstraintVflParserError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ConstraintVflParserError] -> ShowS
$cshowList :: [ConstraintVflParserError] -> ShowS
show :: ConstraintVflParserError -> String
$cshow :: ConstraintVflParserError -> String
showsPrec :: Int -> ConstraintVflParserError -> ShowS
$cshowsPrec :: Int -> ConstraintVflParserError -> ShowS
Show, ConstraintVflParserError -> ConstraintVflParserError -> Bool
(ConstraintVflParserError -> ConstraintVflParserError -> Bool)
-> (ConstraintVflParserError -> ConstraintVflParserError -> Bool)
-> Eq ConstraintVflParserError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ConstraintVflParserError -> ConstraintVflParserError -> Bool
$c/= :: ConstraintVflParserError -> ConstraintVflParserError -> Bool
== :: ConstraintVflParserError -> ConstraintVflParserError -> Bool
$c== :: ConstraintVflParserError -> ConstraintVflParserError -> Bool
Eq)
instance P.Enum ConstraintVflParserError where
fromEnum :: ConstraintVflParserError -> Int
fromEnum ConstraintVflParserError
ConstraintVflParserErrorSymbol = Int
0
fromEnum ConstraintVflParserError
ConstraintVflParserErrorAttribute = Int
1
fromEnum ConstraintVflParserError
ConstraintVflParserErrorView = Int
2
fromEnum ConstraintVflParserError
ConstraintVflParserErrorMetric = Int
3
fromEnum ConstraintVflParserError
ConstraintVflParserErrorPriority = Int
4
fromEnum ConstraintVflParserError
ConstraintVflParserErrorRelation = Int
5
fromEnum (AnotherConstraintVflParserError Int
k) = Int
k
toEnum :: Int -> ConstraintVflParserError
toEnum Int
0 = ConstraintVflParserError
ConstraintVflParserErrorSymbol
toEnum Int
1 = ConstraintVflParserError
ConstraintVflParserErrorAttribute
toEnum Int
2 = ConstraintVflParserError
ConstraintVflParserErrorView
toEnum Int
3 = ConstraintVflParserError
ConstraintVflParserErrorMetric
toEnum Int
4 = ConstraintVflParserError
ConstraintVflParserErrorPriority
toEnum Int
5 = ConstraintVflParserError
ConstraintVflParserErrorRelation
toEnum Int
k = Int -> ConstraintVflParserError
AnotherConstraintVflParserError Int
k
instance P.Ord ConstraintVflParserError where
compare :: ConstraintVflParserError -> ConstraintVflParserError -> Ordering
compare ConstraintVflParserError
a ConstraintVflParserError
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ConstraintVflParserError -> Int
forall a. Enum a => a -> Int
P.fromEnum ConstraintVflParserError
a) (ConstraintVflParserError -> Int
forall a. Enum a => a -> Int
P.fromEnum ConstraintVflParserError
b)
instance GErrorClass ConstraintVflParserError where
gerrorClassDomain :: ConstraintVflParserError -> Text
gerrorClassDomain ConstraintVflParserError
_ = Text
"gtk-constraint-vfl-parser-error-quark"
catchConstraintVflParserError ::
IO a ->
(ConstraintVflParserError -> GErrorMessage -> IO a) ->
IO a
catchConstraintVflParserError :: forall a.
IO a -> (ConstraintVflParserError -> Text -> IO a) -> IO a
catchConstraintVflParserError = IO a -> (ConstraintVflParserError -> Text -> IO a) -> IO a
forall err a.
GErrorClass err =>
IO a -> (err -> Text -> IO a) -> IO a
catchGErrorJustDomain
handleConstraintVflParserError ::
(ConstraintVflParserError -> GErrorMessage -> IO a) ->
IO a ->
IO a
handleConstraintVflParserError :: forall a.
(ConstraintVflParserError -> Text -> IO a) -> IO a -> IO a
handleConstraintVflParserError = (ConstraintVflParserError -> Text -> IO a) -> IO a -> IO a
forall err a.
GErrorClass err =>
(err -> Text -> IO a) -> IO a -> IO a
handleGErrorJustDomain
type instance O.ParentTypes ConstraintVflParserError = '[]
instance O.HasParentTypes ConstraintVflParserError
foreign import ccall "gtk_constraint_vfl_parser_error_get_type" c_gtk_constraint_vfl_parser_error_get_type ::
IO GType
instance B.Types.TypedObject ConstraintVflParserError where
glibType :: IO GType
glibType = IO GType
c_gtk_constraint_vfl_parser_error_get_type
instance B.Types.BoxedEnum ConstraintVflParserError
data ConstraintStrength =
ConstraintStrengthRequired
| ConstraintStrengthStrong
| ConstraintStrengthMedium
| ConstraintStrengthWeak
| AnotherConstraintStrength Int
deriving (Int -> ConstraintStrength -> ShowS
[ConstraintStrength] -> ShowS
ConstraintStrength -> String
(Int -> ConstraintStrength -> ShowS)
-> (ConstraintStrength -> String)
-> ([ConstraintStrength] -> ShowS)
-> Show ConstraintStrength
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ConstraintStrength] -> ShowS
$cshowList :: [ConstraintStrength] -> ShowS
show :: ConstraintStrength -> String
$cshow :: ConstraintStrength -> String
showsPrec :: Int -> ConstraintStrength -> ShowS
$cshowsPrec :: Int -> ConstraintStrength -> ShowS
Show, ConstraintStrength -> ConstraintStrength -> Bool
(ConstraintStrength -> ConstraintStrength -> Bool)
-> (ConstraintStrength -> ConstraintStrength -> Bool)
-> Eq ConstraintStrength
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ConstraintStrength -> ConstraintStrength -> Bool
$c/= :: ConstraintStrength -> ConstraintStrength -> Bool
== :: ConstraintStrength -> ConstraintStrength -> Bool
$c== :: ConstraintStrength -> ConstraintStrength -> Bool
Eq)
instance P.Enum ConstraintStrength where
fromEnum :: ConstraintStrength -> Int
fromEnum ConstraintStrength
ConstraintStrengthRequired = Int
1001001000
fromEnum ConstraintStrength
ConstraintStrengthStrong = Int
1000000000
fromEnum ConstraintStrength
ConstraintStrengthMedium = Int
1000
fromEnum ConstraintStrength
ConstraintStrengthWeak = Int
1
fromEnum (AnotherConstraintStrength Int
k) = Int
k
toEnum :: Int -> ConstraintStrength
toEnum Int
1001001000 = ConstraintStrength
ConstraintStrengthRequired
toEnum Int
1000000000 = ConstraintStrength
ConstraintStrengthStrong
toEnum Int
1000 = ConstraintStrength
ConstraintStrengthMedium
toEnum Int
1 = ConstraintStrength
ConstraintStrengthWeak
toEnum Int
k = Int -> ConstraintStrength
AnotherConstraintStrength Int
k
instance P.Ord ConstraintStrength where
compare :: ConstraintStrength -> ConstraintStrength -> Ordering
compare ConstraintStrength
a ConstraintStrength
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ConstraintStrength -> Int
forall a. Enum a => a -> Int
P.fromEnum ConstraintStrength
a) (ConstraintStrength -> Int
forall a. Enum a => a -> Int
P.fromEnum ConstraintStrength
b)
type instance O.ParentTypes ConstraintStrength = '[]
instance O.HasParentTypes ConstraintStrength
foreign import ccall "gtk_constraint_strength_get_type" c_gtk_constraint_strength_get_type ::
IO GType
instance B.Types.TypedObject ConstraintStrength where
glibType :: IO GType
glibType = IO GType
c_gtk_constraint_strength_get_type
instance B.Types.BoxedEnum ConstraintStrength
data ConstraintRelation =
ConstraintRelationLe
| ConstraintRelationEq
| ConstraintRelationGe
| AnotherConstraintRelation Int
deriving (Int -> ConstraintRelation -> ShowS
[ConstraintRelation] -> ShowS
ConstraintRelation -> String
(Int -> ConstraintRelation -> ShowS)
-> (ConstraintRelation -> String)
-> ([ConstraintRelation] -> ShowS)
-> Show ConstraintRelation
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ConstraintRelation] -> ShowS
$cshowList :: [ConstraintRelation] -> ShowS
show :: ConstraintRelation -> String
$cshow :: ConstraintRelation -> String
showsPrec :: Int -> ConstraintRelation -> ShowS
$cshowsPrec :: Int -> ConstraintRelation -> ShowS
Show, ConstraintRelation -> ConstraintRelation -> Bool
(ConstraintRelation -> ConstraintRelation -> Bool)
-> (ConstraintRelation -> ConstraintRelation -> Bool)
-> Eq ConstraintRelation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ConstraintRelation -> ConstraintRelation -> Bool
$c/= :: ConstraintRelation -> ConstraintRelation -> Bool
== :: ConstraintRelation -> ConstraintRelation -> Bool
$c== :: ConstraintRelation -> ConstraintRelation -> Bool
Eq)
instance P.Enum ConstraintRelation where
fromEnum :: ConstraintRelation -> Int
fromEnum ConstraintRelation
ConstraintRelationLe = Int
-1
fromEnum ConstraintRelation
ConstraintRelationEq = Int
0
fromEnum ConstraintRelation
ConstraintRelationGe = Int
1
fromEnum (AnotherConstraintRelation Int
k) = Int
k
toEnum :: Int -> ConstraintRelation
toEnum Int
-1 = ConstraintRelation
ConstraintRelationLe
toEnum Int
0 = ConstraintRelation
ConstraintRelationEq
toEnum Int
1 = ConstraintRelation
ConstraintRelationGe
toEnum Int
k = Int -> ConstraintRelation
AnotherConstraintRelation Int
k
instance P.Ord ConstraintRelation where
compare :: ConstraintRelation -> ConstraintRelation -> Ordering
compare ConstraintRelation
a ConstraintRelation
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ConstraintRelation -> Int
forall a. Enum a => a -> Int
P.fromEnum ConstraintRelation
a) (ConstraintRelation -> Int
forall a. Enum a => a -> Int
P.fromEnum ConstraintRelation
b)
type instance O.ParentTypes ConstraintRelation = '[]
instance O.HasParentTypes ConstraintRelation
foreign import ccall "gtk_constraint_relation_get_type" c_gtk_constraint_relation_get_type ::
IO GType
instance B.Types.TypedObject ConstraintRelation where
glibType :: IO GType
glibType = IO GType
c_gtk_constraint_relation_get_type
instance B.Types.BoxedEnum ConstraintRelation
data ConstraintAttribute =
ConstraintAttributeNone
| ConstraintAttributeLeft
| ConstraintAttributeRight
| ConstraintAttributeTop
| ConstraintAttributeBottom
| ConstraintAttributeStart
| ConstraintAttributeEnd
| ConstraintAttributeWidth
| ConstraintAttributeHeight
| ConstraintAttributeCenterX
| ConstraintAttributeCenterY
| ConstraintAttributeBaseline
| AnotherConstraintAttribute Int
deriving (Int -> ConstraintAttribute -> ShowS
[ConstraintAttribute] -> ShowS
ConstraintAttribute -> String
(Int -> ConstraintAttribute -> ShowS)
-> (ConstraintAttribute -> String)
-> ([ConstraintAttribute] -> ShowS)
-> Show ConstraintAttribute
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ConstraintAttribute] -> ShowS
$cshowList :: [ConstraintAttribute] -> ShowS
show :: ConstraintAttribute -> String
$cshow :: ConstraintAttribute -> String
showsPrec :: Int -> ConstraintAttribute -> ShowS
$cshowsPrec :: Int -> ConstraintAttribute -> ShowS
Show, ConstraintAttribute -> ConstraintAttribute -> Bool
(ConstraintAttribute -> ConstraintAttribute -> Bool)
-> (ConstraintAttribute -> ConstraintAttribute -> Bool)
-> Eq ConstraintAttribute
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ConstraintAttribute -> ConstraintAttribute -> Bool
$c/= :: ConstraintAttribute -> ConstraintAttribute -> Bool
== :: ConstraintAttribute -> ConstraintAttribute -> Bool
$c== :: ConstraintAttribute -> ConstraintAttribute -> Bool
Eq)
instance P.Enum ConstraintAttribute where
fromEnum :: ConstraintAttribute -> Int
fromEnum ConstraintAttribute
ConstraintAttributeNone = Int
0
fromEnum ConstraintAttribute
ConstraintAttributeLeft = Int
1
fromEnum ConstraintAttribute
ConstraintAttributeRight = Int
2
fromEnum ConstraintAttribute
ConstraintAttributeTop = Int
3
fromEnum ConstraintAttribute
ConstraintAttributeBottom = Int
4
fromEnum ConstraintAttribute
ConstraintAttributeStart = Int
5
fromEnum ConstraintAttribute
ConstraintAttributeEnd = Int
6
fromEnum ConstraintAttribute
ConstraintAttributeWidth = Int
7
fromEnum ConstraintAttribute
ConstraintAttributeHeight = Int
8
fromEnum ConstraintAttribute
ConstraintAttributeCenterX = Int
9
fromEnum ConstraintAttribute
ConstraintAttributeCenterY = Int
10
fromEnum ConstraintAttribute
ConstraintAttributeBaseline = Int
11
fromEnum (AnotherConstraintAttribute Int
k) = Int
k
toEnum :: Int -> ConstraintAttribute
toEnum Int
0 = ConstraintAttribute
ConstraintAttributeNone
toEnum Int
1 = ConstraintAttribute
ConstraintAttributeLeft
toEnum Int
2 = ConstraintAttribute
ConstraintAttributeRight
toEnum Int
3 = ConstraintAttribute
ConstraintAttributeTop
toEnum Int
4 = ConstraintAttribute
ConstraintAttributeBottom
toEnum Int
5 = ConstraintAttribute
ConstraintAttributeStart
toEnum Int
6 = ConstraintAttribute
ConstraintAttributeEnd
toEnum Int
7 = ConstraintAttribute
ConstraintAttributeWidth
toEnum Int
8 = ConstraintAttribute
ConstraintAttributeHeight
toEnum Int
9 = ConstraintAttribute
ConstraintAttributeCenterX
toEnum Int
10 = ConstraintAttribute
ConstraintAttributeCenterY
toEnum Int
11 = ConstraintAttribute
ConstraintAttributeBaseline
toEnum Int
k = Int -> ConstraintAttribute
AnotherConstraintAttribute Int
k
instance P.Ord ConstraintAttribute where
compare :: ConstraintAttribute -> ConstraintAttribute -> Ordering
compare ConstraintAttribute
a ConstraintAttribute
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ConstraintAttribute -> Int
forall a. Enum a => a -> Int
P.fromEnum ConstraintAttribute
a) (ConstraintAttribute -> Int
forall a. Enum a => a -> Int
P.fromEnum ConstraintAttribute
b)
type instance O.ParentTypes ConstraintAttribute = '[]
instance O.HasParentTypes ConstraintAttribute
foreign import ccall "gtk_constraint_attribute_get_type" c_gtk_constraint_attribute_get_type ::
IO GType
instance B.Types.TypedObject ConstraintAttribute where
glibType :: IO GType
glibType = IO GType
c_gtk_constraint_attribute_get_type
instance B.Types.BoxedEnum ConstraintAttribute
data CellRendererMode =
CellRendererModeInert
| CellRendererModeActivatable
| CellRendererModeEditable
| AnotherCellRendererMode Int
deriving (Int -> CellRendererMode -> ShowS
[CellRendererMode] -> ShowS
CellRendererMode -> String
(Int -> CellRendererMode -> ShowS)
-> (CellRendererMode -> String)
-> ([CellRendererMode] -> ShowS)
-> Show CellRendererMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CellRendererMode] -> ShowS
$cshowList :: [CellRendererMode] -> ShowS
show :: CellRendererMode -> String
$cshow :: CellRendererMode -> String
showsPrec :: Int -> CellRendererMode -> ShowS
$cshowsPrec :: Int -> CellRendererMode -> ShowS
Show, CellRendererMode -> CellRendererMode -> Bool
(CellRendererMode -> CellRendererMode -> Bool)
-> (CellRendererMode -> CellRendererMode -> Bool)
-> Eq CellRendererMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CellRendererMode -> CellRendererMode -> Bool
$c/= :: CellRendererMode -> CellRendererMode -> Bool
== :: CellRendererMode -> CellRendererMode -> Bool
$c== :: CellRendererMode -> CellRendererMode -> Bool
Eq)
instance P.Enum CellRendererMode where
fromEnum :: CellRendererMode -> Int
fromEnum CellRendererMode
CellRendererModeInert = Int
0
fromEnum CellRendererMode
CellRendererModeActivatable = Int
1
fromEnum CellRendererMode
CellRendererModeEditable = Int
2
fromEnum (AnotherCellRendererMode Int
k) = Int
k
toEnum :: Int -> CellRendererMode
toEnum Int
0 = CellRendererMode
CellRendererModeInert
toEnum Int
1 = CellRendererMode
CellRendererModeActivatable
toEnum Int
2 = CellRendererMode
CellRendererModeEditable
toEnum Int
k = Int -> CellRendererMode
AnotherCellRendererMode Int
k
instance P.Ord CellRendererMode where
compare :: CellRendererMode -> CellRendererMode -> Ordering
compare CellRendererMode
a CellRendererMode
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (CellRendererMode -> Int
forall a. Enum a => a -> Int
P.fromEnum CellRendererMode
a) (CellRendererMode -> Int
forall a. Enum a => a -> Int
P.fromEnum CellRendererMode
b)
type instance O.ParentTypes CellRendererMode = '[]
instance O.HasParentTypes CellRendererMode
foreign import ccall "gtk_cell_renderer_mode_get_type" c_gtk_cell_renderer_mode_get_type ::
IO GType
instance B.Types.TypedObject CellRendererMode where
glibType :: IO GType
glibType = IO GType
c_gtk_cell_renderer_mode_get_type
instance B.Types.BoxedEnum CellRendererMode
data CellRendererAccelMode =
CellRendererAccelModeGtk
| CellRendererAccelModeOther
| AnotherCellRendererAccelMode Int
deriving (Int -> CellRendererAccelMode -> ShowS
[CellRendererAccelMode] -> ShowS
CellRendererAccelMode -> String
(Int -> CellRendererAccelMode -> ShowS)
-> (CellRendererAccelMode -> String)
-> ([CellRendererAccelMode] -> ShowS)
-> Show CellRendererAccelMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CellRendererAccelMode] -> ShowS
$cshowList :: [CellRendererAccelMode] -> ShowS
show :: CellRendererAccelMode -> String
$cshow :: CellRendererAccelMode -> String
showsPrec :: Int -> CellRendererAccelMode -> ShowS
$cshowsPrec :: Int -> CellRendererAccelMode -> ShowS
Show, CellRendererAccelMode -> CellRendererAccelMode -> Bool
(CellRendererAccelMode -> CellRendererAccelMode -> Bool)
-> (CellRendererAccelMode -> CellRendererAccelMode -> Bool)
-> Eq CellRendererAccelMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CellRendererAccelMode -> CellRendererAccelMode -> Bool
$c/= :: CellRendererAccelMode -> CellRendererAccelMode -> Bool
== :: CellRendererAccelMode -> CellRendererAccelMode -> Bool
$c== :: CellRendererAccelMode -> CellRendererAccelMode -> Bool
Eq)
instance P.Enum CellRendererAccelMode where
fromEnum :: CellRendererAccelMode -> Int
fromEnum CellRendererAccelMode
CellRendererAccelModeGtk = Int
0
fromEnum CellRendererAccelMode
CellRendererAccelModeOther = Int
1
fromEnum (AnotherCellRendererAccelMode Int
k) = Int
k
toEnum :: Int -> CellRendererAccelMode
toEnum Int
0 = CellRendererAccelMode
CellRendererAccelModeGtk
toEnum Int
1 = CellRendererAccelMode
CellRendererAccelModeOther
toEnum Int
k = Int -> CellRendererAccelMode
AnotherCellRendererAccelMode Int
k
instance P.Ord CellRendererAccelMode where
compare :: CellRendererAccelMode -> CellRendererAccelMode -> Ordering
compare CellRendererAccelMode
a CellRendererAccelMode
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (CellRendererAccelMode -> Int
forall a. Enum a => a -> Int
P.fromEnum CellRendererAccelMode
a) (CellRendererAccelMode -> Int
forall a. Enum a => a -> Int
P.fromEnum CellRendererAccelMode
b)
type instance O.ParentTypes CellRendererAccelMode = '[]
instance O.HasParentTypes CellRendererAccelMode
foreign import ccall "gtk_cell_renderer_accel_mode_get_type" c_gtk_cell_renderer_accel_mode_get_type ::
IO GType
instance B.Types.TypedObject CellRendererAccelMode where
glibType :: IO GType
glibType = IO GType
c_gtk_cell_renderer_accel_mode_get_type
instance B.Types.BoxedEnum CellRendererAccelMode
data ButtonsType =
ButtonsTypeNone
| ButtonsTypeOk
| ButtonsTypeClose
| ButtonsTypeCancel
| ButtonsTypeYesNo
| ButtonsTypeOkCancel
| AnotherButtonsType Int
deriving (Int -> ButtonsType -> ShowS
[ButtonsType] -> ShowS
ButtonsType -> String
(Int -> ButtonsType -> ShowS)
-> (ButtonsType -> String)
-> ([ButtonsType] -> ShowS)
-> Show ButtonsType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ButtonsType] -> ShowS
$cshowList :: [ButtonsType] -> ShowS
show :: ButtonsType -> String
$cshow :: ButtonsType -> String
showsPrec :: Int -> ButtonsType -> ShowS
$cshowsPrec :: Int -> ButtonsType -> ShowS
Show, ButtonsType -> ButtonsType -> Bool
(ButtonsType -> ButtonsType -> Bool)
-> (ButtonsType -> ButtonsType -> Bool) -> Eq ButtonsType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ButtonsType -> ButtonsType -> Bool
$c/= :: ButtonsType -> ButtonsType -> Bool
== :: ButtonsType -> ButtonsType -> Bool
$c== :: ButtonsType -> ButtonsType -> Bool
Eq)
instance P.Enum ButtonsType where
fromEnum :: ButtonsType -> Int
fromEnum ButtonsType
ButtonsTypeNone = Int
0
fromEnum ButtonsType
ButtonsTypeOk = Int
1
fromEnum ButtonsType
ButtonsTypeClose = Int
2
fromEnum ButtonsType
ButtonsTypeCancel = Int
3
fromEnum ButtonsType
ButtonsTypeYesNo = Int
4
fromEnum ButtonsType
ButtonsTypeOkCancel = Int
5
fromEnum (AnotherButtonsType Int
k) = Int
k
toEnum :: Int -> ButtonsType
toEnum Int
0 = ButtonsType
ButtonsTypeNone
toEnum Int
1 = ButtonsType
ButtonsTypeOk
toEnum Int
2 = ButtonsType
ButtonsTypeClose
toEnum Int
3 = ButtonsType
ButtonsTypeCancel
toEnum Int
4 = ButtonsType
ButtonsTypeYesNo
toEnum Int
5 = ButtonsType
ButtonsTypeOkCancel
toEnum Int
k = Int -> ButtonsType
AnotherButtonsType Int
k
instance P.Ord ButtonsType where
compare :: ButtonsType -> ButtonsType -> Ordering
compare ButtonsType
a ButtonsType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ButtonsType -> Int
forall a. Enum a => a -> Int
P.fromEnum ButtonsType
a) (ButtonsType -> Int
forall a. Enum a => a -> Int
P.fromEnum ButtonsType
b)
type instance O.ParentTypes ButtonsType = '[]
instance O.HasParentTypes ButtonsType
foreign import ccall "gtk_buttons_type_get_type" c_gtk_buttons_type_get_type ::
IO GType
instance B.Types.TypedObject ButtonsType where
glibType :: IO GType
glibType = IO GType
c_gtk_buttons_type_get_type
instance B.Types.BoxedEnum ButtonsType
data BuilderError =
BuilderErrorInvalidTypeFunction
| BuilderErrorUnhandledTag
| BuilderErrorMissingAttribute
| BuilderErrorInvalidAttribute
| BuilderErrorInvalidTag
| BuilderErrorMissingPropertyValue
| BuilderErrorInvalidValue
| BuilderErrorVersionMismatch
| BuilderErrorDuplicateId
| BuilderErrorObjectTypeRefused
| BuilderErrorTemplateMismatch
| BuilderErrorInvalidProperty
| BuilderErrorInvalidSignal
| BuilderErrorInvalidId
| BuilderErrorInvalidFunction
| AnotherBuilderError Int
deriving (Int -> BuilderError -> ShowS
[BuilderError] -> ShowS
BuilderError -> String
(Int -> BuilderError -> ShowS)
-> (BuilderError -> String)
-> ([BuilderError] -> ShowS)
-> Show BuilderError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BuilderError] -> ShowS
$cshowList :: [BuilderError] -> ShowS
show :: BuilderError -> String
$cshow :: BuilderError -> String
showsPrec :: Int -> BuilderError -> ShowS
$cshowsPrec :: Int -> BuilderError -> ShowS
Show, BuilderError -> BuilderError -> Bool
(BuilderError -> BuilderError -> Bool)
-> (BuilderError -> BuilderError -> Bool) -> Eq BuilderError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BuilderError -> BuilderError -> Bool
$c/= :: BuilderError -> BuilderError -> Bool
== :: BuilderError -> BuilderError -> Bool
$c== :: BuilderError -> BuilderError -> Bool
Eq)
instance P.Enum BuilderError where
fromEnum :: BuilderError -> Int
fromEnum BuilderError
BuilderErrorInvalidTypeFunction = Int
0
fromEnum BuilderError
BuilderErrorUnhandledTag = Int
1
fromEnum BuilderError
BuilderErrorMissingAttribute = Int
2
fromEnum BuilderError
BuilderErrorInvalidAttribute = Int
3
fromEnum BuilderError
BuilderErrorInvalidTag = Int
4
fromEnum BuilderError
BuilderErrorMissingPropertyValue = Int
5
fromEnum BuilderError
BuilderErrorInvalidValue = Int
6
fromEnum BuilderError
BuilderErrorVersionMismatch = Int
7
fromEnum BuilderError
BuilderErrorDuplicateId = Int
8
fromEnum BuilderError
BuilderErrorObjectTypeRefused = Int
9
fromEnum BuilderError
BuilderErrorTemplateMismatch = Int
10
fromEnum BuilderError
BuilderErrorInvalidProperty = Int
11
fromEnum BuilderError
BuilderErrorInvalidSignal = Int
12
fromEnum BuilderError
BuilderErrorInvalidId = Int
13
fromEnum BuilderError
BuilderErrorInvalidFunction = Int
14
fromEnum (AnotherBuilderError Int
k) = Int
k
toEnum :: Int -> BuilderError
toEnum Int
0 = BuilderError
BuilderErrorInvalidTypeFunction
toEnum Int
1 = BuilderError
BuilderErrorUnhandledTag
toEnum Int
2 = BuilderError
BuilderErrorMissingAttribute
toEnum Int
3 = BuilderError
BuilderErrorInvalidAttribute
toEnum Int
4 = BuilderError
BuilderErrorInvalidTag
toEnum Int
5 = BuilderError
BuilderErrorMissingPropertyValue
toEnum Int
6 = BuilderError
BuilderErrorInvalidValue
toEnum Int
7 = BuilderError
BuilderErrorVersionMismatch
toEnum Int
8 = BuilderError
BuilderErrorDuplicateId
toEnum Int
9 = BuilderError
BuilderErrorObjectTypeRefused
toEnum Int
10 = BuilderError
BuilderErrorTemplateMismatch
toEnum Int
11 = BuilderError
BuilderErrorInvalidProperty
toEnum Int
12 = BuilderError
BuilderErrorInvalidSignal
toEnum Int
13 = BuilderError
BuilderErrorInvalidId
toEnum Int
14 = BuilderError
BuilderErrorInvalidFunction
toEnum Int
k = Int -> BuilderError
AnotherBuilderError Int
k
instance P.Ord BuilderError where
compare :: BuilderError -> BuilderError -> Ordering
compare BuilderError
a BuilderError
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (BuilderError -> Int
forall a. Enum a => a -> Int
P.fromEnum BuilderError
a) (BuilderError -> Int
forall a. Enum a => a -> Int
P.fromEnum BuilderError
b)
instance GErrorClass BuilderError where
gerrorClassDomain :: BuilderError -> Text
gerrorClassDomain BuilderError
_ = Text
"gtk-builder-error-quark"
catchBuilderError ::
IO a ->
(BuilderError -> GErrorMessage -> IO a) ->
IO a
catchBuilderError :: forall a. IO a -> (BuilderError -> Text -> IO a) -> IO a
catchBuilderError = IO a -> (BuilderError -> Text -> IO a) -> IO a
forall err a.
GErrorClass err =>
IO a -> (err -> Text -> IO a) -> IO a
catchGErrorJustDomain
handleBuilderError ::
(BuilderError -> GErrorMessage -> IO a) ->
IO a ->
IO a
handleBuilderError :: forall a. (BuilderError -> Text -> IO a) -> IO a -> IO a
handleBuilderError = (BuilderError -> Text -> IO a) -> IO a -> IO a
forall err a.
GErrorClass err =>
(err -> Text -> IO a) -> IO a -> IO a
handleGErrorJustDomain
type instance O.ParentTypes BuilderError = '[]
instance O.HasParentTypes BuilderError
foreign import ccall "gtk_builder_error_get_type" c_gtk_builder_error_get_type ::
IO GType
instance B.Types.TypedObject BuilderError where
glibType :: IO GType
glibType = IO GType
c_gtk_builder_error_get_type
instance B.Types.BoxedEnum BuilderError
data BorderStyle =
BorderStyleNone
| BorderStyleHidden
| BorderStyleSolid
| BorderStyleInset
| BorderStyleOutset
| BorderStyleDotted
| BorderStyleDashed
| BorderStyleDouble
| BorderStyleGroove
| BorderStyleRidge
| AnotherBorderStyle Int
deriving (Int -> BorderStyle -> ShowS
[BorderStyle] -> ShowS
BorderStyle -> String
(Int -> BorderStyle -> ShowS)
-> (BorderStyle -> String)
-> ([BorderStyle] -> ShowS)
-> Show BorderStyle
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BorderStyle] -> ShowS
$cshowList :: [BorderStyle] -> ShowS
show :: BorderStyle -> String
$cshow :: BorderStyle -> String
showsPrec :: Int -> BorderStyle -> ShowS
$cshowsPrec :: Int -> BorderStyle -> ShowS
Show, BorderStyle -> BorderStyle -> Bool
(BorderStyle -> BorderStyle -> Bool)
-> (BorderStyle -> BorderStyle -> Bool) -> Eq BorderStyle
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BorderStyle -> BorderStyle -> Bool
$c/= :: BorderStyle -> BorderStyle -> Bool
== :: BorderStyle -> BorderStyle -> Bool
$c== :: BorderStyle -> BorderStyle -> Bool
Eq)
instance P.Enum BorderStyle where
fromEnum :: BorderStyle -> Int
fromEnum BorderStyle
BorderStyleNone = Int
0
fromEnum BorderStyle
BorderStyleHidden = Int
1
fromEnum BorderStyle
BorderStyleSolid = Int
2
fromEnum BorderStyle
BorderStyleInset = Int
3
fromEnum BorderStyle
BorderStyleOutset = Int
4
fromEnum BorderStyle
BorderStyleDotted = Int
5
fromEnum BorderStyle
BorderStyleDashed = Int
6
fromEnum BorderStyle
BorderStyleDouble = Int
7
fromEnum BorderStyle
BorderStyleGroove = Int
8
fromEnum BorderStyle
BorderStyleRidge = Int
9
fromEnum (AnotherBorderStyle Int
k) = Int
k
toEnum :: Int -> BorderStyle
toEnum Int
0 = BorderStyle
BorderStyleNone
toEnum Int
1 = BorderStyle
BorderStyleHidden
toEnum Int
2 = BorderStyle
BorderStyleSolid
toEnum Int
3 = BorderStyle
BorderStyleInset
toEnum Int
4 = BorderStyle
BorderStyleOutset
toEnum Int
5 = BorderStyle
BorderStyleDotted
toEnum Int
6 = BorderStyle
BorderStyleDashed
toEnum Int
7 = BorderStyle
BorderStyleDouble
toEnum Int
8 = BorderStyle
BorderStyleGroove
toEnum Int
9 = BorderStyle
BorderStyleRidge
toEnum Int
k = Int -> BorderStyle
AnotherBorderStyle Int
k
instance P.Ord BorderStyle where
compare :: BorderStyle -> BorderStyle -> Ordering
compare BorderStyle
a BorderStyle
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (BorderStyle -> Int
forall a. Enum a => a -> Int
P.fromEnum BorderStyle
a) (BorderStyle -> Int
forall a. Enum a => a -> Int
P.fromEnum BorderStyle
b)
type instance O.ParentTypes BorderStyle = '[]
instance O.HasParentTypes BorderStyle
foreign import ccall "gtk_border_style_get_type" c_gtk_border_style_get_type ::
IO GType
instance B.Types.TypedObject BorderStyle where
glibType :: IO GType
glibType = IO GType
c_gtk_border_style_get_type
instance B.Types.BoxedEnum BorderStyle
data BaselinePosition =
BaselinePositionTop
| BaselinePositionCenter
| BaselinePositionBottom
| AnotherBaselinePosition Int
deriving (Int -> BaselinePosition -> ShowS
[BaselinePosition] -> ShowS
BaselinePosition -> String
(Int -> BaselinePosition -> ShowS)
-> (BaselinePosition -> String)
-> ([BaselinePosition] -> ShowS)
-> Show BaselinePosition
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BaselinePosition] -> ShowS
$cshowList :: [BaselinePosition] -> ShowS
show :: BaselinePosition -> String
$cshow :: BaselinePosition -> String
showsPrec :: Int -> BaselinePosition -> ShowS
$cshowsPrec :: Int -> BaselinePosition -> ShowS
Show, BaselinePosition -> BaselinePosition -> Bool
(BaselinePosition -> BaselinePosition -> Bool)
-> (BaselinePosition -> BaselinePosition -> Bool)
-> Eq BaselinePosition
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BaselinePosition -> BaselinePosition -> Bool
$c/= :: BaselinePosition -> BaselinePosition -> Bool
== :: BaselinePosition -> BaselinePosition -> Bool
$c== :: BaselinePosition -> BaselinePosition -> Bool
Eq)
instance P.Enum BaselinePosition where
fromEnum :: BaselinePosition -> Int
fromEnum BaselinePosition
BaselinePositionTop = Int
0
fromEnum BaselinePosition
BaselinePositionCenter = Int
1
fromEnum BaselinePosition
BaselinePositionBottom = Int
2
fromEnum (AnotherBaselinePosition Int
k) = Int
k
toEnum :: Int -> BaselinePosition
toEnum Int
0 = BaselinePosition
BaselinePositionTop
toEnum Int
1 = BaselinePosition
BaselinePositionCenter
toEnum Int
2 = BaselinePosition
BaselinePositionBottom
toEnum Int
k = Int -> BaselinePosition
AnotherBaselinePosition Int
k
instance P.Ord BaselinePosition where
compare :: BaselinePosition -> BaselinePosition -> Ordering
compare BaselinePosition
a BaselinePosition
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (BaselinePosition -> Int
forall a. Enum a => a -> Int
P.fromEnum BaselinePosition
a) (BaselinePosition -> Int
forall a. Enum a => a -> Int
P.fromEnum BaselinePosition
b)
type instance O.ParentTypes BaselinePosition = '[]
instance O.HasParentTypes BaselinePosition
foreign import ccall "gtk_baseline_position_get_type" c_gtk_baseline_position_get_type ::
IO GType
instance B.Types.TypedObject BaselinePosition where
glibType :: IO GType
glibType = IO GType
c_gtk_baseline_position_get_type
instance B.Types.BoxedEnum BaselinePosition
data AssistantPageType =
AssistantPageTypeContent
| AssistantPageTypeIntro
| AssistantPageTypeConfirm
| AssistantPageTypeSummary
| AssistantPageTypeProgress
| AssistantPageTypeCustom
| AnotherAssistantPageType Int
deriving (Int -> AssistantPageType -> ShowS
[AssistantPageType] -> ShowS
AssistantPageType -> String
(Int -> AssistantPageType -> ShowS)
-> (AssistantPageType -> String)
-> ([AssistantPageType] -> ShowS)
-> Show AssistantPageType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AssistantPageType] -> ShowS
$cshowList :: [AssistantPageType] -> ShowS
show :: AssistantPageType -> String
$cshow :: AssistantPageType -> String
showsPrec :: Int -> AssistantPageType -> ShowS
$cshowsPrec :: Int -> AssistantPageType -> ShowS
Show, AssistantPageType -> AssistantPageType -> Bool
(AssistantPageType -> AssistantPageType -> Bool)
-> (AssistantPageType -> AssistantPageType -> Bool)
-> Eq AssistantPageType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AssistantPageType -> AssistantPageType -> Bool
$c/= :: AssistantPageType -> AssistantPageType -> Bool
== :: AssistantPageType -> AssistantPageType -> Bool
$c== :: AssistantPageType -> AssistantPageType -> Bool
Eq)
instance P.Enum AssistantPageType where
fromEnum :: AssistantPageType -> Int
fromEnum AssistantPageType
AssistantPageTypeContent = Int
0
fromEnum AssistantPageType
AssistantPageTypeIntro = Int
1
fromEnum AssistantPageType
AssistantPageTypeConfirm = Int
2
fromEnum AssistantPageType
AssistantPageTypeSummary = Int
3
fromEnum AssistantPageType
AssistantPageTypeProgress = Int
4
fromEnum AssistantPageType
AssistantPageTypeCustom = Int
5
fromEnum (AnotherAssistantPageType Int
k) = Int
k
toEnum :: Int -> AssistantPageType
toEnum Int
0 = AssistantPageType
AssistantPageTypeContent
toEnum Int
1 = AssistantPageType
AssistantPageTypeIntro
toEnum Int
2 = AssistantPageType
AssistantPageTypeConfirm
toEnum Int
3 = AssistantPageType
AssistantPageTypeSummary
toEnum Int
4 = AssistantPageType
AssistantPageTypeProgress
toEnum Int
5 = AssistantPageType
AssistantPageTypeCustom
toEnum Int
k = Int -> AssistantPageType
AnotherAssistantPageType Int
k
instance P.Ord AssistantPageType where
compare :: AssistantPageType -> AssistantPageType -> Ordering
compare AssistantPageType
a AssistantPageType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (AssistantPageType -> Int
forall a. Enum a => a -> Int
P.fromEnum AssistantPageType
a) (AssistantPageType -> Int
forall a. Enum a => a -> Int
P.fromEnum AssistantPageType
b)
type instance O.ParentTypes AssistantPageType = '[]
instance O.HasParentTypes AssistantPageType
foreign import ccall "gtk_assistant_page_type_get_type" c_gtk_assistant_page_type_get_type ::
IO GType
instance B.Types.TypedObject AssistantPageType where
glibType :: IO GType
glibType = IO GType
c_gtk_assistant_page_type_get_type
instance B.Types.BoxedEnum AssistantPageType
data ArrowType =
ArrowTypeUp
| ArrowTypeDown
| ArrowTypeLeft
| ArrowTypeRight
| ArrowTypeNone
| AnotherArrowType Int
deriving (Int -> ArrowType -> ShowS
[ArrowType] -> ShowS
ArrowType -> String
(Int -> ArrowType -> ShowS)
-> (ArrowType -> String)
-> ([ArrowType] -> ShowS)
-> Show ArrowType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ArrowType] -> ShowS
$cshowList :: [ArrowType] -> ShowS
show :: ArrowType -> String
$cshow :: ArrowType -> String
showsPrec :: Int -> ArrowType -> ShowS
$cshowsPrec :: Int -> ArrowType -> ShowS
Show, ArrowType -> ArrowType -> Bool
(ArrowType -> ArrowType -> Bool)
-> (ArrowType -> ArrowType -> Bool) -> Eq ArrowType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ArrowType -> ArrowType -> Bool
$c/= :: ArrowType -> ArrowType -> Bool
== :: ArrowType -> ArrowType -> Bool
$c== :: ArrowType -> ArrowType -> Bool
Eq)
instance P.Enum ArrowType where
fromEnum :: ArrowType -> Int
fromEnum ArrowType
ArrowTypeUp = Int
0
fromEnum ArrowType
ArrowTypeDown = Int
1
fromEnum ArrowType
ArrowTypeLeft = Int
2
fromEnum ArrowType
ArrowTypeRight = Int
3
fromEnum ArrowType
ArrowTypeNone = Int
4
fromEnum (AnotherArrowType Int
k) = Int
k
toEnum :: Int -> ArrowType
toEnum Int
0 = ArrowType
ArrowTypeUp
toEnum Int
1 = ArrowType
ArrowTypeDown
toEnum Int
2 = ArrowType
ArrowTypeLeft
toEnum Int
3 = ArrowType
ArrowTypeRight
toEnum Int
4 = ArrowType
ArrowTypeNone
toEnum Int
k = Int -> ArrowType
AnotherArrowType Int
k
instance P.Ord ArrowType where
compare :: ArrowType -> ArrowType -> Ordering
compare ArrowType
a ArrowType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ArrowType -> Int
forall a. Enum a => a -> Int
P.fromEnum ArrowType
a) (ArrowType -> Int
forall a. Enum a => a -> Int
P.fromEnum ArrowType
b)
type instance O.ParentTypes ArrowType = '[]
instance O.HasParentTypes ArrowType
foreign import ccall "gtk_arrow_type_get_type" c_gtk_arrow_type_get_type ::
IO GType
instance B.Types.TypedObject ArrowType where
glibType :: IO GType
glibType = IO GType
c_gtk_arrow_type_get_type
instance B.Types.BoxedEnum ArrowType
data Align =
AlignFill
| AlignStart
| AlignEnd
| AlignCenter
| AlignBaseline
| AnotherAlign Int
deriving (Int -> Align -> ShowS
[Align] -> ShowS
Align -> String
(Int -> Align -> ShowS)
-> (Align -> String) -> ([Align] -> ShowS) -> Show Align
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Align] -> ShowS
$cshowList :: [Align] -> ShowS
show :: Align -> String
$cshow :: Align -> String
showsPrec :: Int -> Align -> ShowS
$cshowsPrec :: Int -> Align -> ShowS
Show, Align -> Align -> Bool
(Align -> Align -> Bool) -> (Align -> Align -> Bool) -> Eq Align
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Align -> Align -> Bool
$c/= :: Align -> Align -> Bool
== :: Align -> Align -> Bool
$c== :: Align -> Align -> Bool
Eq)
instance P.Enum Align where
fromEnum :: Align -> Int
fromEnum Align
AlignFill = Int
0
fromEnum Align
AlignStart = Int
1
fromEnum Align
AlignEnd = Int
2
fromEnum Align
AlignCenter = Int
3
fromEnum Align
AlignBaseline = Int
4
fromEnum (AnotherAlign Int
k) = Int
k
toEnum :: Int -> Align
toEnum Int
0 = Align
AlignFill
toEnum Int
1 = Align
AlignStart
toEnum Int
2 = Align
AlignEnd
toEnum Int
3 = Align
AlignCenter
toEnum Int
4 = Align
AlignBaseline
toEnum Int
k = Int -> Align
AnotherAlign Int
k
instance P.Ord Align where
compare :: Align -> Align -> Ordering
compare Align
a Align
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (Align -> Int
forall a. Enum a => a -> Int
P.fromEnum Align
a) (Align -> Int
forall a. Enum a => a -> Int
P.fromEnum Align
b)
type instance O.ParentTypes Align = '[]
instance O.HasParentTypes Align
foreign import ccall "gtk_align_get_type" c_gtk_align_get_type ::
IO GType
instance B.Types.TypedObject Align where
glibType :: IO GType
glibType = IO GType
c_gtk_align_get_type
instance B.Types.BoxedEnum Align
data AccessibleTristate =
AccessibleTristateFalse
| AccessibleTristateTrue
| AccessibleTristateMixed
| AnotherAccessibleTristate Int
deriving (Int -> AccessibleTristate -> ShowS
[AccessibleTristate] -> ShowS
AccessibleTristate -> String
(Int -> AccessibleTristate -> ShowS)
-> (AccessibleTristate -> String)
-> ([AccessibleTristate] -> ShowS)
-> Show AccessibleTristate
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AccessibleTristate] -> ShowS
$cshowList :: [AccessibleTristate] -> ShowS
show :: AccessibleTristate -> String
$cshow :: AccessibleTristate -> String
showsPrec :: Int -> AccessibleTristate -> ShowS
$cshowsPrec :: Int -> AccessibleTristate -> ShowS
Show, AccessibleTristate -> AccessibleTristate -> Bool
(AccessibleTristate -> AccessibleTristate -> Bool)
-> (AccessibleTristate -> AccessibleTristate -> Bool)
-> Eq AccessibleTristate
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AccessibleTristate -> AccessibleTristate -> Bool
$c/= :: AccessibleTristate -> AccessibleTristate -> Bool
== :: AccessibleTristate -> AccessibleTristate -> Bool
$c== :: AccessibleTristate -> AccessibleTristate -> Bool
Eq)
instance P.Enum AccessibleTristate where
fromEnum :: AccessibleTristate -> Int
fromEnum AccessibleTristate
AccessibleTristateFalse = Int
0
fromEnum AccessibleTristate
AccessibleTristateTrue = Int
1
fromEnum AccessibleTristate
AccessibleTristateMixed = Int
2
fromEnum (AnotherAccessibleTristate Int
k) = Int
k
toEnum :: Int -> AccessibleTristate
toEnum Int
0 = AccessibleTristate
AccessibleTristateFalse
toEnum Int
1 = AccessibleTristate
AccessibleTristateTrue
toEnum Int
2 = AccessibleTristate
AccessibleTristateMixed
toEnum Int
k = Int -> AccessibleTristate
AnotherAccessibleTristate Int
k
instance P.Ord AccessibleTristate where
compare :: AccessibleTristate -> AccessibleTristate -> Ordering
compare AccessibleTristate
a AccessibleTristate
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (AccessibleTristate -> Int
forall a. Enum a => a -> Int
P.fromEnum AccessibleTristate
a) (AccessibleTristate -> Int
forall a. Enum a => a -> Int
P.fromEnum AccessibleTristate
b)
type instance O.ParentTypes AccessibleTristate = '[]
instance O.HasParentTypes AccessibleTristate
foreign import ccall "gtk_accessible_tristate_get_type" c_gtk_accessible_tristate_get_type ::
IO GType
instance B.Types.TypedObject AccessibleTristate where
glibType :: IO GType
glibType = IO GType
c_gtk_accessible_tristate_get_type
instance B.Types.BoxedEnum AccessibleTristate
data AccessibleState =
AccessibleStateBusy
| AccessibleStateChecked
| AccessibleStateDisabled
| AccessibleStateExpanded
| AccessibleStateHidden
| AccessibleStateInvalid
| AccessibleStatePressed
| AccessibleStateSelected
| AnotherAccessibleState Int
deriving (Int -> AccessibleState -> ShowS
[AccessibleState] -> ShowS
AccessibleState -> String
(Int -> AccessibleState -> ShowS)
-> (AccessibleState -> String)
-> ([AccessibleState] -> ShowS)
-> Show AccessibleState
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AccessibleState] -> ShowS
$cshowList :: [AccessibleState] -> ShowS
show :: AccessibleState -> String
$cshow :: AccessibleState -> String
showsPrec :: Int -> AccessibleState -> ShowS
$cshowsPrec :: Int -> AccessibleState -> ShowS
Show, AccessibleState -> AccessibleState -> Bool
(AccessibleState -> AccessibleState -> Bool)
-> (AccessibleState -> AccessibleState -> Bool)
-> Eq AccessibleState
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AccessibleState -> AccessibleState -> Bool
$c/= :: AccessibleState -> AccessibleState -> Bool
== :: AccessibleState -> AccessibleState -> Bool
$c== :: AccessibleState -> AccessibleState -> Bool
Eq)
instance P.Enum AccessibleState where
fromEnum :: AccessibleState -> Int
fromEnum AccessibleState
AccessibleStateBusy = Int
0
fromEnum AccessibleState
AccessibleStateChecked = Int
1
fromEnum AccessibleState
AccessibleStateDisabled = Int
2
fromEnum AccessibleState
AccessibleStateExpanded = Int
3
fromEnum AccessibleState
AccessibleStateHidden = Int
4
fromEnum AccessibleState
AccessibleStateInvalid = Int
5
fromEnum AccessibleState
AccessibleStatePressed = Int
6
fromEnum AccessibleState
AccessibleStateSelected = Int
7
fromEnum (AnotherAccessibleState Int
k) = Int
k
toEnum :: Int -> AccessibleState
toEnum Int
0 = AccessibleState
AccessibleStateBusy
toEnum Int
1 = AccessibleState
AccessibleStateChecked
toEnum Int
2 = AccessibleState
AccessibleStateDisabled
toEnum Int
3 = AccessibleState
AccessibleStateExpanded
toEnum Int
4 = AccessibleState
AccessibleStateHidden
toEnum Int
5 = AccessibleState
AccessibleStateInvalid
toEnum Int
6 = AccessibleState
AccessibleStatePressed
toEnum Int
7 = AccessibleState
AccessibleStateSelected
toEnum Int
k = Int -> AccessibleState
AnotherAccessibleState Int
k
instance P.Ord AccessibleState where
compare :: AccessibleState -> AccessibleState -> Ordering
compare AccessibleState
a AccessibleState
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (AccessibleState -> Int
forall a. Enum a => a -> Int
P.fromEnum AccessibleState
a) (AccessibleState -> Int
forall a. Enum a => a -> Int
P.fromEnum AccessibleState
b)
type instance O.ParentTypes AccessibleState = '[]
instance O.HasParentTypes AccessibleState
foreign import ccall "gtk_accessible_state_get_type" c_gtk_accessible_state_get_type ::
IO GType
instance B.Types.TypedObject AccessibleState where
glibType :: IO GType
glibType = IO GType
c_gtk_accessible_state_get_type
instance B.Types.BoxedEnum AccessibleState
data AccessibleSort =
AccessibleSortNone
| AccessibleSortAscending
| AccessibleSortDescending
| AccessibleSortOther
| AnotherAccessibleSort Int
deriving (Int -> AccessibleSort -> ShowS
[AccessibleSort] -> ShowS
AccessibleSort -> String
(Int -> AccessibleSort -> ShowS)
-> (AccessibleSort -> String)
-> ([AccessibleSort] -> ShowS)
-> Show AccessibleSort
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AccessibleSort] -> ShowS
$cshowList :: [AccessibleSort] -> ShowS
show :: AccessibleSort -> String
$cshow :: AccessibleSort -> String
showsPrec :: Int -> AccessibleSort -> ShowS
$cshowsPrec :: Int -> AccessibleSort -> ShowS
Show, AccessibleSort -> AccessibleSort -> Bool
(AccessibleSort -> AccessibleSort -> Bool)
-> (AccessibleSort -> AccessibleSort -> Bool) -> Eq AccessibleSort
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AccessibleSort -> AccessibleSort -> Bool
$c/= :: AccessibleSort -> AccessibleSort -> Bool
== :: AccessibleSort -> AccessibleSort -> Bool
$c== :: AccessibleSort -> AccessibleSort -> Bool
Eq)
instance P.Enum AccessibleSort where
fromEnum :: AccessibleSort -> Int
fromEnum AccessibleSort
AccessibleSortNone = Int
0
fromEnum AccessibleSort
AccessibleSortAscending = Int
1
fromEnum AccessibleSort
AccessibleSortDescending = Int
2
fromEnum AccessibleSort
AccessibleSortOther = Int
3
fromEnum (AnotherAccessibleSort Int
k) = Int
k
toEnum :: Int -> AccessibleSort
toEnum Int
0 = AccessibleSort
AccessibleSortNone
toEnum Int
1 = AccessibleSort
AccessibleSortAscending
toEnum Int
2 = AccessibleSort
AccessibleSortDescending
toEnum Int
3 = AccessibleSort
AccessibleSortOther
toEnum Int
k = Int -> AccessibleSort
AnotherAccessibleSort Int
k
instance P.Ord AccessibleSort where
compare :: AccessibleSort -> AccessibleSort -> Ordering
compare AccessibleSort
a AccessibleSort
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (AccessibleSort -> Int
forall a. Enum a => a -> Int
P.fromEnum AccessibleSort
a) (AccessibleSort -> Int
forall a. Enum a => a -> Int
P.fromEnum AccessibleSort
b)
type instance O.ParentTypes AccessibleSort = '[]
instance O.HasParentTypes AccessibleSort
foreign import ccall "gtk_accessible_sort_get_type" c_gtk_accessible_sort_get_type ::
IO GType
instance B.Types.TypedObject AccessibleSort where
glibType :: IO GType
glibType = IO GType
c_gtk_accessible_sort_get_type
instance B.Types.BoxedEnum AccessibleSort
data AccessibleRole =
AccessibleRoleAlert
| AccessibleRoleAlertDialog
| AccessibleRoleBanner
| AccessibleRoleButton
| AccessibleRoleCaption
| AccessibleRoleCell
| AccessibleRoleCheckbox
| AccessibleRoleColumnHeader
| AccessibleRoleComboBox
| AccessibleRoleCommand
| AccessibleRoleComposite
| AccessibleRoleDialog
| AccessibleRoleDocument
| AccessibleRoleFeed
| AccessibleRoleForm
| AccessibleRoleGeneric
| AccessibleRoleGrid
| AccessibleRoleGridCell
| AccessibleRoleGroup
| AccessibleRoleHeading
| AccessibleRoleImg
| AccessibleRoleInput
| AccessibleRoleLabel
| AccessibleRoleLandmark
| AccessibleRoleLegend
| AccessibleRoleLink
| AccessibleRoleList
| AccessibleRoleListBox
| AccessibleRoleListItem
| AccessibleRoleLog
| AccessibleRoleMain
| AccessibleRoleMarquee
| AccessibleRoleMath
| AccessibleRoleMeter
|
|
|
|
|
| AccessibleRoleNavigation
| AccessibleRoleNone
| AccessibleRoleNote
| AccessibleRoleOption
| AccessibleRolePresentation
| AccessibleRoleProgressBar
| AccessibleRoleRadio
| AccessibleRoleRadioGroup
| AccessibleRoleRange
| AccessibleRoleRegion
| AccessibleRoleRow
| AccessibleRoleRowGroup
|
| AccessibleRoleScrollbar
| AccessibleRoleSearch
| AccessibleRoleSearchBox
| AccessibleRoleSection
| AccessibleRoleSectionHead
| AccessibleRoleSelect
| AccessibleRoleSeparator
| AccessibleRoleSlider
| AccessibleRoleSpinButton
| AccessibleRoleStatus
| AccessibleRoleStructure
| AccessibleRoleSwitch
| AccessibleRoleTab
| AccessibleRoleTable
| AccessibleRoleTabList
| AccessibleRoleTabPanel
| AccessibleRoleTextBox
| AccessibleRoleTime
| AccessibleRoleTimer
| AccessibleRoleToolbar
| AccessibleRoleTooltip
| AccessibleRoleTree
| AccessibleRoleTreeGrid
| AccessibleRoleTreeItem
| AccessibleRoleWidget
| AccessibleRoleWindow
| AnotherAccessibleRole Int
deriving (Int -> AccessibleRole -> ShowS
[AccessibleRole] -> ShowS
AccessibleRole -> String
(Int -> AccessibleRole -> ShowS)
-> (AccessibleRole -> String)
-> ([AccessibleRole] -> ShowS)
-> Show AccessibleRole
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AccessibleRole] -> ShowS
$cshowList :: [AccessibleRole] -> ShowS
show :: AccessibleRole -> String
$cshow :: AccessibleRole -> String
showsPrec :: Int -> AccessibleRole -> ShowS
$cshowsPrec :: Int -> AccessibleRole -> ShowS
Show, AccessibleRole -> AccessibleRole -> Bool
(AccessibleRole -> AccessibleRole -> Bool)
-> (AccessibleRole -> AccessibleRole -> Bool) -> Eq AccessibleRole
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AccessibleRole -> AccessibleRole -> Bool
$c/= :: AccessibleRole -> AccessibleRole -> Bool
== :: AccessibleRole -> AccessibleRole -> Bool
$c== :: AccessibleRole -> AccessibleRole -> Bool
Eq)
instance P.Enum AccessibleRole where
fromEnum :: AccessibleRole -> Int
fromEnum AccessibleRole
AccessibleRoleAlert = Int
0
fromEnum AccessibleRole
AccessibleRoleAlertDialog = Int
1
fromEnum AccessibleRole
AccessibleRoleBanner = Int
2
fromEnum AccessibleRole
AccessibleRoleButton = Int
3
fromEnum AccessibleRole
AccessibleRoleCaption = Int
4
fromEnum AccessibleRole
AccessibleRoleCell = Int
5
fromEnum AccessibleRole
AccessibleRoleCheckbox = Int
6
fromEnum AccessibleRole
AccessibleRoleColumnHeader = Int
7
fromEnum AccessibleRole
AccessibleRoleComboBox = Int
8
fromEnum AccessibleRole
AccessibleRoleCommand = Int
9
fromEnum AccessibleRole
AccessibleRoleComposite = Int
10
fromEnum AccessibleRole
AccessibleRoleDialog = Int
11
fromEnum AccessibleRole
AccessibleRoleDocument = Int
12
fromEnum AccessibleRole
AccessibleRoleFeed = Int
13
fromEnum AccessibleRole
AccessibleRoleForm = Int
14
fromEnum AccessibleRole
AccessibleRoleGeneric = Int
15
fromEnum AccessibleRole
AccessibleRoleGrid = Int
16
fromEnum AccessibleRole
AccessibleRoleGridCell = Int
17
fromEnum AccessibleRole
AccessibleRoleGroup = Int
18
fromEnum AccessibleRole
AccessibleRoleHeading = Int
19
fromEnum AccessibleRole
AccessibleRoleImg = Int
20
fromEnum AccessibleRole
AccessibleRoleInput = Int
21
fromEnum AccessibleRole
AccessibleRoleLabel = Int
22
fromEnum AccessibleRole
AccessibleRoleLandmark = Int
23
fromEnum AccessibleRole
AccessibleRoleLegend = Int
24
fromEnum AccessibleRole
AccessibleRoleLink = Int
25
fromEnum AccessibleRole
AccessibleRoleList = Int
26
fromEnum AccessibleRole
AccessibleRoleListBox = Int
27
fromEnum AccessibleRole
AccessibleRoleListItem = Int
28
fromEnum AccessibleRole
AccessibleRoleLog = Int
29
fromEnum AccessibleRole
AccessibleRoleMain = Int
30
fromEnum AccessibleRole
AccessibleRoleMarquee = Int
31
fromEnum AccessibleRole
AccessibleRoleMath = Int
32
fromEnum AccessibleRole
AccessibleRoleMeter = Int
33
fromEnum AccessibleRole
AccessibleRoleMenu = Int
34
fromEnum AccessibleRole
AccessibleRoleMenuBar = Int
35
fromEnum AccessibleRole
AccessibleRoleMenuItem = Int
36
fromEnum AccessibleRole
AccessibleRoleMenuItemCheckbox = Int
37
fromEnum AccessibleRole
AccessibleRoleMenuItemRadio = Int
38
fromEnum AccessibleRole
AccessibleRoleNavigation = Int
39
fromEnum AccessibleRole
AccessibleRoleNone = Int
40
fromEnum AccessibleRole
AccessibleRoleNote = Int
41
fromEnum AccessibleRole
AccessibleRoleOption = Int
42
fromEnum AccessibleRole
AccessibleRolePresentation = Int
43
fromEnum AccessibleRole
AccessibleRoleProgressBar = Int
44
fromEnum AccessibleRole
AccessibleRoleRadio = Int
45
fromEnum AccessibleRole
AccessibleRoleRadioGroup = Int
46
fromEnum AccessibleRole
AccessibleRoleRange = Int
47
fromEnum AccessibleRole
AccessibleRoleRegion = Int
48
fromEnum AccessibleRole
AccessibleRoleRow = Int
49
fromEnum AccessibleRole
AccessibleRoleRowGroup = Int
50
fromEnum AccessibleRole
AccessibleRoleRowHeader = Int
51
fromEnum AccessibleRole
AccessibleRoleScrollbar = Int
52
fromEnum AccessibleRole
AccessibleRoleSearch = Int
53
fromEnum AccessibleRole
AccessibleRoleSearchBox = Int
54
fromEnum AccessibleRole
AccessibleRoleSection = Int
55
fromEnum AccessibleRole
AccessibleRoleSectionHead = Int
56
fromEnum AccessibleRole
AccessibleRoleSelect = Int
57
fromEnum AccessibleRole
AccessibleRoleSeparator = Int
58
fromEnum AccessibleRole
AccessibleRoleSlider = Int
59
fromEnum AccessibleRole
AccessibleRoleSpinButton = Int
60
fromEnum AccessibleRole
AccessibleRoleStatus = Int
61
fromEnum AccessibleRole
AccessibleRoleStructure = Int
62
fromEnum AccessibleRole
AccessibleRoleSwitch = Int
63
fromEnum AccessibleRole
AccessibleRoleTab = Int
64
fromEnum AccessibleRole
AccessibleRoleTable = Int
65
fromEnum AccessibleRole
AccessibleRoleTabList = Int
66
fromEnum AccessibleRole
AccessibleRoleTabPanel = Int
67
fromEnum AccessibleRole
AccessibleRoleTextBox = Int
68
fromEnum AccessibleRole
AccessibleRoleTime = Int
69
fromEnum AccessibleRole
AccessibleRoleTimer = Int
70
fromEnum AccessibleRole
AccessibleRoleToolbar = Int
71
fromEnum AccessibleRole
AccessibleRoleTooltip = Int
72
fromEnum AccessibleRole
AccessibleRoleTree = Int
73
fromEnum AccessibleRole
AccessibleRoleTreeGrid = Int
74
fromEnum AccessibleRole
AccessibleRoleTreeItem = Int
75
fromEnum AccessibleRole
AccessibleRoleWidget = Int
76
fromEnum AccessibleRole
AccessibleRoleWindow = Int
77
fromEnum (AnotherAccessibleRole Int
k) = Int
k
toEnum :: Int -> AccessibleRole
toEnum Int
0 = AccessibleRole
AccessibleRoleAlert
toEnum Int
1 = AccessibleRole
AccessibleRoleAlertDialog
toEnum Int
2 = AccessibleRole
AccessibleRoleBanner
toEnum Int
3 = AccessibleRole
AccessibleRoleButton
toEnum Int
4 = AccessibleRole
AccessibleRoleCaption
toEnum Int
5 = AccessibleRole
AccessibleRoleCell
toEnum Int
6 = AccessibleRole
AccessibleRoleCheckbox
toEnum Int
7 = AccessibleRole
AccessibleRoleColumnHeader
toEnum Int
8 = AccessibleRole
AccessibleRoleComboBox
toEnum Int
9 = AccessibleRole
AccessibleRoleCommand
toEnum Int
10 = AccessibleRole
AccessibleRoleComposite
toEnum Int
11 = AccessibleRole
AccessibleRoleDialog
toEnum Int
12 = AccessibleRole
AccessibleRoleDocument
toEnum Int
13 = AccessibleRole
AccessibleRoleFeed
toEnum Int
14 = AccessibleRole
AccessibleRoleForm
toEnum Int
15 = AccessibleRole
AccessibleRoleGeneric
toEnum Int
16 = AccessibleRole
AccessibleRoleGrid
toEnum Int
17 = AccessibleRole
AccessibleRoleGridCell
toEnum Int
18 = AccessibleRole
AccessibleRoleGroup
toEnum Int
19 = AccessibleRole
AccessibleRoleHeading
toEnum Int
20 = AccessibleRole
AccessibleRoleImg
toEnum Int
21 = AccessibleRole
AccessibleRoleInput
toEnum Int
22 = AccessibleRole
AccessibleRoleLabel
toEnum Int
23 = AccessibleRole
AccessibleRoleLandmark
toEnum Int
24 = AccessibleRole
AccessibleRoleLegend
toEnum Int
25 = AccessibleRole
AccessibleRoleLink
toEnum Int
26 = AccessibleRole
AccessibleRoleList
toEnum Int
27 = AccessibleRole
AccessibleRoleListBox
toEnum Int
28 = AccessibleRole
AccessibleRoleListItem
toEnum Int
29 = AccessibleRole
AccessibleRoleLog
toEnum Int
30 = AccessibleRole
AccessibleRoleMain
toEnum Int
31 = AccessibleRole
AccessibleRoleMarquee
toEnum Int
32 = AccessibleRole
AccessibleRoleMath
toEnum Int
33 = AccessibleRole
AccessibleRoleMeter
toEnum Int
34 = AccessibleRole
AccessibleRoleMenu
toEnum Int
35 = AccessibleRole
AccessibleRoleMenuBar
toEnum Int
36 = AccessibleRole
AccessibleRoleMenuItem
toEnum Int
37 = AccessibleRole
AccessibleRoleMenuItemCheckbox
toEnum Int
38 = AccessibleRole
AccessibleRoleMenuItemRadio
toEnum Int
39 = AccessibleRole
AccessibleRoleNavigation
toEnum Int
40 = AccessibleRole
AccessibleRoleNone
toEnum Int
41 = AccessibleRole
AccessibleRoleNote
toEnum Int
42 = AccessibleRole
AccessibleRoleOption
toEnum Int
43 = AccessibleRole
AccessibleRolePresentation
toEnum Int
44 = AccessibleRole
AccessibleRoleProgressBar
toEnum Int
45 = AccessibleRole
AccessibleRoleRadio
toEnum Int
46 = AccessibleRole
AccessibleRoleRadioGroup
toEnum Int
47 = AccessibleRole
AccessibleRoleRange
toEnum Int
48 = AccessibleRole
AccessibleRoleRegion
toEnum Int
49 = AccessibleRole
AccessibleRoleRow
toEnum Int
50 = AccessibleRole
AccessibleRoleRowGroup
toEnum Int
51 = AccessibleRole
AccessibleRoleRowHeader
toEnum Int
52 = AccessibleRole
AccessibleRoleScrollbar
toEnum Int
53 = AccessibleRole
AccessibleRoleSearch
toEnum Int
54 = AccessibleRole
AccessibleRoleSearchBox
toEnum Int
55 = AccessibleRole
AccessibleRoleSection
toEnum Int
56 = AccessibleRole
AccessibleRoleSectionHead
toEnum Int
57 = AccessibleRole
AccessibleRoleSelect
toEnum Int
58 = AccessibleRole
AccessibleRoleSeparator
toEnum Int
59 = AccessibleRole
AccessibleRoleSlider
toEnum Int
60 = AccessibleRole
AccessibleRoleSpinButton
toEnum Int
61 = AccessibleRole
AccessibleRoleStatus
toEnum Int
62 = AccessibleRole
AccessibleRoleStructure
toEnum Int
63 = AccessibleRole
AccessibleRoleSwitch
toEnum Int
64 = AccessibleRole
AccessibleRoleTab
toEnum Int
65 = AccessibleRole
AccessibleRoleTable
toEnum Int
66 = AccessibleRole
AccessibleRoleTabList
toEnum Int
67 = AccessibleRole
AccessibleRoleTabPanel
toEnum Int
68 = AccessibleRole
AccessibleRoleTextBox
toEnum Int
69 = AccessibleRole
AccessibleRoleTime
toEnum Int
70 = AccessibleRole
AccessibleRoleTimer
toEnum Int
71 = AccessibleRole
AccessibleRoleToolbar
toEnum Int
72 = AccessibleRole
AccessibleRoleTooltip
toEnum Int
73 = AccessibleRole
AccessibleRoleTree
toEnum Int
74 = AccessibleRole
AccessibleRoleTreeGrid
toEnum Int
75 = AccessibleRole
AccessibleRoleTreeItem
toEnum Int
76 = AccessibleRole
AccessibleRoleWidget
toEnum Int
77 = AccessibleRole
AccessibleRoleWindow
toEnum Int
k = Int -> AccessibleRole
AnotherAccessibleRole Int
k
instance P.Ord AccessibleRole where
compare :: AccessibleRole -> AccessibleRole -> Ordering
compare AccessibleRole
a AccessibleRole
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (AccessibleRole -> Int
forall a. Enum a => a -> Int
P.fromEnum AccessibleRole
a) (AccessibleRole -> Int
forall a. Enum a => a -> Int
P.fromEnum AccessibleRole
b)
type instance O.ParentTypes AccessibleRole = '[]
instance O.HasParentTypes AccessibleRole
foreign import ccall "gtk_accessible_role_get_type" c_gtk_accessible_role_get_type ::
IO GType
instance B.Types.TypedObject AccessibleRole where
glibType :: IO GType
glibType = IO GType
c_gtk_accessible_role_get_type
instance B.Types.BoxedEnum AccessibleRole
data AccessibleRelation =
AccessibleRelationActiveDescendant
| AccessibleRelationColCount
| AccessibleRelationColIndex
| AccessibleRelationColIndexText
| AccessibleRelationColSpan
| AccessibleRelationControls
| AccessibleRelationDescribedBy
| AccessibleRelationDetails
| AccessibleRelationErrorMessage
| AccessibleRelationFlowTo
| AccessibleRelationLabelledBy
| AccessibleRelationOwns
| AccessibleRelationPosInSet
| AccessibleRelationRowCount
| AccessibleRelationRowIndex
| AccessibleRelationRowIndexText
| AccessibleRelationRowSpan
| AccessibleRelationSetSize
| AnotherAccessibleRelation Int
deriving (Int -> AccessibleRelation -> ShowS
[AccessibleRelation] -> ShowS
AccessibleRelation -> String
(Int -> AccessibleRelation -> ShowS)
-> (AccessibleRelation -> String)
-> ([AccessibleRelation] -> ShowS)
-> Show AccessibleRelation
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AccessibleRelation] -> ShowS
$cshowList :: [AccessibleRelation] -> ShowS
show :: AccessibleRelation -> String
$cshow :: AccessibleRelation -> String
showsPrec :: Int -> AccessibleRelation -> ShowS
$cshowsPrec :: Int -> AccessibleRelation -> ShowS
Show, AccessibleRelation -> AccessibleRelation -> Bool
(AccessibleRelation -> AccessibleRelation -> Bool)
-> (AccessibleRelation -> AccessibleRelation -> Bool)
-> Eq AccessibleRelation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AccessibleRelation -> AccessibleRelation -> Bool
$c/= :: AccessibleRelation -> AccessibleRelation -> Bool
== :: AccessibleRelation -> AccessibleRelation -> Bool
$c== :: AccessibleRelation -> AccessibleRelation -> Bool
Eq)
instance P.Enum AccessibleRelation where
fromEnum :: AccessibleRelation -> Int
fromEnum AccessibleRelation
AccessibleRelationActiveDescendant = Int
0
fromEnum AccessibleRelation
AccessibleRelationColCount = Int
1
fromEnum AccessibleRelation
AccessibleRelationColIndex = Int
2
fromEnum AccessibleRelation
AccessibleRelationColIndexText = Int
3
fromEnum AccessibleRelation
AccessibleRelationColSpan = Int
4
fromEnum AccessibleRelation
AccessibleRelationControls = Int
5
fromEnum AccessibleRelation
AccessibleRelationDescribedBy = Int
6
fromEnum AccessibleRelation
AccessibleRelationDetails = Int
7
fromEnum AccessibleRelation
AccessibleRelationErrorMessage = Int
8
fromEnum AccessibleRelation
AccessibleRelationFlowTo = Int
9
fromEnum AccessibleRelation
AccessibleRelationLabelledBy = Int
10
fromEnum AccessibleRelation
AccessibleRelationOwns = Int
11
fromEnum AccessibleRelation
AccessibleRelationPosInSet = Int
12
fromEnum AccessibleRelation
AccessibleRelationRowCount = Int
13
fromEnum AccessibleRelation
AccessibleRelationRowIndex = Int
14
fromEnum AccessibleRelation
AccessibleRelationRowIndexText = Int
15
fromEnum AccessibleRelation
AccessibleRelationRowSpan = Int
16
fromEnum AccessibleRelation
AccessibleRelationSetSize = Int
17
fromEnum (AnotherAccessibleRelation Int
k) = Int
k
toEnum :: Int -> AccessibleRelation
toEnum Int
0 = AccessibleRelation
AccessibleRelationActiveDescendant
toEnum Int
1 = AccessibleRelation
AccessibleRelationColCount
toEnum Int
2 = AccessibleRelation
AccessibleRelationColIndex
toEnum Int
3 = AccessibleRelation
AccessibleRelationColIndexText
toEnum Int
4 = AccessibleRelation
AccessibleRelationColSpan
toEnum Int
5 = AccessibleRelation
AccessibleRelationControls
toEnum Int
6 = AccessibleRelation
AccessibleRelationDescribedBy
toEnum Int
7 = AccessibleRelation
AccessibleRelationDetails
toEnum Int
8 = AccessibleRelation
AccessibleRelationErrorMessage
toEnum Int
9 = AccessibleRelation
AccessibleRelationFlowTo
toEnum Int
10 = AccessibleRelation
AccessibleRelationLabelledBy
toEnum Int
11 = AccessibleRelation
AccessibleRelationOwns
toEnum Int
12 = AccessibleRelation
AccessibleRelationPosInSet
toEnum Int
13 = AccessibleRelation
AccessibleRelationRowCount
toEnum Int
14 = AccessibleRelation
AccessibleRelationRowIndex
toEnum Int
15 = AccessibleRelation
AccessibleRelationRowIndexText
toEnum Int
16 = AccessibleRelation
AccessibleRelationRowSpan
toEnum Int
17 = AccessibleRelation
AccessibleRelationSetSize
toEnum Int
k = Int -> AccessibleRelation
AnotherAccessibleRelation Int
k
instance P.Ord AccessibleRelation where
compare :: AccessibleRelation -> AccessibleRelation -> Ordering
compare AccessibleRelation
a AccessibleRelation
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (AccessibleRelation -> Int
forall a. Enum a => a -> Int
P.fromEnum AccessibleRelation
a) (AccessibleRelation -> Int
forall a. Enum a => a -> Int
P.fromEnum AccessibleRelation
b)
type instance O.ParentTypes AccessibleRelation = '[]
instance O.HasParentTypes AccessibleRelation
foreign import ccall "gtk_accessible_relation_get_type" c_gtk_accessible_relation_get_type ::
IO GType
instance B.Types.TypedObject AccessibleRelation where
glibType :: IO GType
glibType = IO GType
c_gtk_accessible_relation_get_type
instance B.Types.BoxedEnum AccessibleRelation
data AccessibleProperty =
AccessiblePropertyAutocomplete
| AccessiblePropertyDescription
|
| AccessiblePropertyKeyShortcuts
| AccessiblePropertyLabel
| AccessiblePropertyLevel
| AccessiblePropertyModal
| AccessiblePropertyMultiLine
| AccessiblePropertyMultiSelectable
| AccessiblePropertyOrientation
| AccessiblePropertyPlaceholder
| AccessiblePropertyReadOnly
| AccessiblePropertyRequired
| AccessiblePropertyRoleDescription
| AccessiblePropertySort
| AccessiblePropertyValueMax
| AccessiblePropertyValueMin
| AccessiblePropertyValueNow
| AccessiblePropertyValueText
| AnotherAccessibleProperty Int
deriving (Int -> AccessibleProperty -> ShowS
[AccessibleProperty] -> ShowS
AccessibleProperty -> String
(Int -> AccessibleProperty -> ShowS)
-> (AccessibleProperty -> String)
-> ([AccessibleProperty] -> ShowS)
-> Show AccessibleProperty
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AccessibleProperty] -> ShowS
$cshowList :: [AccessibleProperty] -> ShowS
show :: AccessibleProperty -> String
$cshow :: AccessibleProperty -> String
showsPrec :: Int -> AccessibleProperty -> ShowS
$cshowsPrec :: Int -> AccessibleProperty -> ShowS
Show, AccessibleProperty -> AccessibleProperty -> Bool
(AccessibleProperty -> AccessibleProperty -> Bool)
-> (AccessibleProperty -> AccessibleProperty -> Bool)
-> Eq AccessibleProperty
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AccessibleProperty -> AccessibleProperty -> Bool
$c/= :: AccessibleProperty -> AccessibleProperty -> Bool
== :: AccessibleProperty -> AccessibleProperty -> Bool
$c== :: AccessibleProperty -> AccessibleProperty -> Bool
Eq)
instance P.Enum AccessibleProperty where
fromEnum :: AccessibleProperty -> Int
fromEnum AccessibleProperty
AccessiblePropertyAutocomplete = Int
0
fromEnum AccessibleProperty
AccessiblePropertyDescription = Int
1
fromEnum AccessibleProperty
AccessiblePropertyHasPopup = Int
2
fromEnum AccessibleProperty
AccessiblePropertyKeyShortcuts = Int
3
fromEnum AccessibleProperty
AccessiblePropertyLabel = Int
4
fromEnum AccessibleProperty
AccessiblePropertyLevel = Int
5
fromEnum AccessibleProperty
AccessiblePropertyModal = Int
6
fromEnum AccessibleProperty
AccessiblePropertyMultiLine = Int
7
fromEnum AccessibleProperty
AccessiblePropertyMultiSelectable = Int
8
fromEnum AccessibleProperty
AccessiblePropertyOrientation = Int
9
fromEnum AccessibleProperty
AccessiblePropertyPlaceholder = Int
10
fromEnum AccessibleProperty
AccessiblePropertyReadOnly = Int
11
fromEnum AccessibleProperty
AccessiblePropertyRequired = Int
12
fromEnum AccessibleProperty
AccessiblePropertyRoleDescription = Int
13
fromEnum AccessibleProperty
AccessiblePropertySort = Int
14
fromEnum AccessibleProperty
AccessiblePropertyValueMax = Int
15
fromEnum AccessibleProperty
AccessiblePropertyValueMin = Int
16
fromEnum AccessibleProperty
AccessiblePropertyValueNow = Int
17
fromEnum AccessibleProperty
AccessiblePropertyValueText = Int
18
fromEnum (AnotherAccessibleProperty Int
k) = Int
k
toEnum :: Int -> AccessibleProperty
toEnum Int
0 = AccessibleProperty
AccessiblePropertyAutocomplete
toEnum Int
1 = AccessibleProperty
AccessiblePropertyDescription
toEnum Int
2 = AccessibleProperty
AccessiblePropertyHasPopup
toEnum Int
3 = AccessibleProperty
AccessiblePropertyKeyShortcuts
toEnum Int
4 = AccessibleProperty
AccessiblePropertyLabel
toEnum Int
5 = AccessibleProperty
AccessiblePropertyLevel
toEnum Int
6 = AccessibleProperty
AccessiblePropertyModal
toEnum Int
7 = AccessibleProperty
AccessiblePropertyMultiLine
toEnum Int
8 = AccessibleProperty
AccessiblePropertyMultiSelectable
toEnum Int
9 = AccessibleProperty
AccessiblePropertyOrientation
toEnum Int
10 = AccessibleProperty
AccessiblePropertyPlaceholder
toEnum Int
11 = AccessibleProperty
AccessiblePropertyReadOnly
toEnum Int
12 = AccessibleProperty
AccessiblePropertyRequired
toEnum Int
13 = AccessibleProperty
AccessiblePropertyRoleDescription
toEnum Int
14 = AccessibleProperty
AccessiblePropertySort
toEnum Int
15 = AccessibleProperty
AccessiblePropertyValueMax
toEnum Int
16 = AccessibleProperty
AccessiblePropertyValueMin
toEnum Int
17 = AccessibleProperty
AccessiblePropertyValueNow
toEnum Int
18 = AccessibleProperty
AccessiblePropertyValueText
toEnum Int
k = Int -> AccessibleProperty
AnotherAccessibleProperty Int
k
instance P.Ord AccessibleProperty where
compare :: AccessibleProperty -> AccessibleProperty -> Ordering
compare AccessibleProperty
a AccessibleProperty
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (AccessibleProperty -> Int
forall a. Enum a => a -> Int
P.fromEnum AccessibleProperty
a) (AccessibleProperty -> Int
forall a. Enum a => a -> Int
P.fromEnum AccessibleProperty
b)
type instance O.ParentTypes AccessibleProperty = '[]
instance O.HasParentTypes AccessibleProperty
foreign import ccall "gtk_accessible_property_get_type" c_gtk_accessible_property_get_type ::
IO GType
instance B.Types.TypedObject AccessibleProperty where
glibType :: IO GType
glibType = IO GType
c_gtk_accessible_property_get_type
instance B.Types.BoxedEnum AccessibleProperty
data AccessibleInvalidState =
AccessibleInvalidStateFalse
| AccessibleInvalidStateTrue
| AccessibleInvalidStateGrammar
| AccessibleInvalidStateSpelling
| AnotherAccessibleInvalidState Int
deriving (Int -> AccessibleInvalidState -> ShowS
[AccessibleInvalidState] -> ShowS
AccessibleInvalidState -> String
(Int -> AccessibleInvalidState -> ShowS)
-> (AccessibleInvalidState -> String)
-> ([AccessibleInvalidState] -> ShowS)
-> Show AccessibleInvalidState
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AccessibleInvalidState] -> ShowS
$cshowList :: [AccessibleInvalidState] -> ShowS
show :: AccessibleInvalidState -> String
$cshow :: AccessibleInvalidState -> String
showsPrec :: Int -> AccessibleInvalidState -> ShowS
$cshowsPrec :: Int -> AccessibleInvalidState -> ShowS
Show, AccessibleInvalidState -> AccessibleInvalidState -> Bool
(AccessibleInvalidState -> AccessibleInvalidState -> Bool)
-> (AccessibleInvalidState -> AccessibleInvalidState -> Bool)
-> Eq AccessibleInvalidState
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AccessibleInvalidState -> AccessibleInvalidState -> Bool
$c/= :: AccessibleInvalidState -> AccessibleInvalidState -> Bool
== :: AccessibleInvalidState -> AccessibleInvalidState -> Bool
$c== :: AccessibleInvalidState -> AccessibleInvalidState -> Bool
Eq)
instance P.Enum AccessibleInvalidState where
fromEnum :: AccessibleInvalidState -> Int
fromEnum AccessibleInvalidState
AccessibleInvalidStateFalse = Int
0
fromEnum AccessibleInvalidState
AccessibleInvalidStateTrue = Int
1
fromEnum AccessibleInvalidState
AccessibleInvalidStateGrammar = Int
2
fromEnum AccessibleInvalidState
AccessibleInvalidStateSpelling = Int
3
fromEnum (AnotherAccessibleInvalidState Int
k) = Int
k
toEnum :: Int -> AccessibleInvalidState
toEnum Int
0 = AccessibleInvalidState
AccessibleInvalidStateFalse
toEnum Int
1 = AccessibleInvalidState
AccessibleInvalidStateTrue
toEnum Int
2 = AccessibleInvalidState
AccessibleInvalidStateGrammar
toEnum Int
3 = AccessibleInvalidState
AccessibleInvalidStateSpelling
toEnum Int
k = Int -> AccessibleInvalidState
AnotherAccessibleInvalidState Int
k
instance P.Ord AccessibleInvalidState where
compare :: AccessibleInvalidState -> AccessibleInvalidState -> Ordering
compare AccessibleInvalidState
a AccessibleInvalidState
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (AccessibleInvalidState -> Int
forall a. Enum a => a -> Int
P.fromEnum AccessibleInvalidState
a) (AccessibleInvalidState -> Int
forall a. Enum a => a -> Int
P.fromEnum AccessibleInvalidState
b)
type instance O.ParentTypes AccessibleInvalidState = '[]
instance O.HasParentTypes AccessibleInvalidState
foreign import ccall "gtk_accessible_invalid_state_get_type" c_gtk_accessible_invalid_state_get_type ::
IO GType
instance B.Types.TypedObject AccessibleInvalidState where
glibType :: IO GType
glibType = IO GType
c_gtk_accessible_invalid_state_get_type
instance B.Types.BoxedEnum AccessibleInvalidState
data AccessibleAutocomplete =
AccessibleAutocompleteNone
| AccessibleAutocompleteInline
| AccessibleAutocompleteList
| AccessibleAutocompleteBoth
| AnotherAccessibleAutocomplete Int
deriving (Int -> AccessibleAutocomplete -> ShowS
[AccessibleAutocomplete] -> ShowS
AccessibleAutocomplete -> String
(Int -> AccessibleAutocomplete -> ShowS)
-> (AccessibleAutocomplete -> String)
-> ([AccessibleAutocomplete] -> ShowS)
-> Show AccessibleAutocomplete
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AccessibleAutocomplete] -> ShowS
$cshowList :: [AccessibleAutocomplete] -> ShowS
show :: AccessibleAutocomplete -> String
$cshow :: AccessibleAutocomplete -> String
showsPrec :: Int -> AccessibleAutocomplete -> ShowS
$cshowsPrec :: Int -> AccessibleAutocomplete -> ShowS
Show, AccessibleAutocomplete -> AccessibleAutocomplete -> Bool
(AccessibleAutocomplete -> AccessibleAutocomplete -> Bool)
-> (AccessibleAutocomplete -> AccessibleAutocomplete -> Bool)
-> Eq AccessibleAutocomplete
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AccessibleAutocomplete -> AccessibleAutocomplete -> Bool
$c/= :: AccessibleAutocomplete -> AccessibleAutocomplete -> Bool
== :: AccessibleAutocomplete -> AccessibleAutocomplete -> Bool
$c== :: AccessibleAutocomplete -> AccessibleAutocomplete -> Bool
Eq)
instance P.Enum AccessibleAutocomplete where
fromEnum :: AccessibleAutocomplete -> Int
fromEnum AccessibleAutocomplete
AccessibleAutocompleteNone = Int
0
fromEnum AccessibleAutocomplete
AccessibleAutocompleteInline = Int
1
fromEnum AccessibleAutocomplete
AccessibleAutocompleteList = Int
2
fromEnum AccessibleAutocomplete
AccessibleAutocompleteBoth = Int
3
fromEnum (AnotherAccessibleAutocomplete Int
k) = Int
k
toEnum :: Int -> AccessibleAutocomplete
toEnum Int
0 = AccessibleAutocomplete
AccessibleAutocompleteNone
toEnum Int
1 = AccessibleAutocomplete
AccessibleAutocompleteInline
toEnum Int
2 = AccessibleAutocomplete
AccessibleAutocompleteList
toEnum Int
3 = AccessibleAutocomplete
AccessibleAutocompleteBoth
toEnum Int
k = Int -> AccessibleAutocomplete
AnotherAccessibleAutocomplete Int
k
instance P.Ord AccessibleAutocomplete where
compare :: AccessibleAutocomplete -> AccessibleAutocomplete -> Ordering
compare AccessibleAutocomplete
a AccessibleAutocomplete
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (AccessibleAutocomplete -> Int
forall a. Enum a => a -> Int
P.fromEnum AccessibleAutocomplete
a) (AccessibleAutocomplete -> Int
forall a. Enum a => a -> Int
P.fromEnum AccessibleAutocomplete
b)
type instance O.ParentTypes AccessibleAutocomplete = '[]
instance O.HasParentTypes AccessibleAutocomplete
foreign import ccall "gtk_accessible_autocomplete_get_type" c_gtk_accessible_autocomplete_get_type ::
IO GType
instance B.Types.TypedObject AccessibleAutocomplete where
glibType :: IO GType
glibType = IO GType
c_gtk_accessible_autocomplete_get_type
instance B.Types.BoxedEnum AccessibleAutocomplete