#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gdk.Enums
(
AxisUse(..) ,
ByteOrder(..) ,
CrossingMode(..) ,
CursorType(..) ,
DevicePadFeature(..) ,
DeviceToolType(..) ,
DeviceType(..) ,
DragCancelReason(..) ,
DragProtocol(..) ,
EventType(..) ,
FilterReturn(..) ,
FullscreenMode(..) ,
GLError(..) ,
catchGLError ,
handleGLError ,
GrabOwnership(..) ,
GrabStatus(..) ,
Gravity(..) ,
InputMode(..) ,
InputSource(..) ,
ModifierIntent(..) ,
NotifyType(..) ,
OwnerChange(..) ,
PropMode(..) ,
PropertyState(..) ,
ScrollDirection(..) ,
SettingAction(..) ,
Status(..) ,
SubpixelLayout(..) ,
TouchpadGesturePhase(..) ,
VisibilityState(..) ,
VisualType(..) ,
WindowEdge(..) ,
WindowType(..) ,
WindowTypeHint(..) ,
WindowWindowClass(..) ,
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
data WindowWindowClass =
WindowWindowClassInputOutput
| WindowWindowClassInputOnly
| AnotherWindowWindowClass Int
deriving (Int -> WindowWindowClass -> ShowS
[WindowWindowClass] -> ShowS
WindowWindowClass -> String
(Int -> WindowWindowClass -> ShowS)
-> (WindowWindowClass -> String)
-> ([WindowWindowClass] -> ShowS)
-> Show WindowWindowClass
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [WindowWindowClass] -> ShowS
$cshowList :: [WindowWindowClass] -> ShowS
show :: WindowWindowClass -> String
$cshow :: WindowWindowClass -> String
showsPrec :: Int -> WindowWindowClass -> ShowS
$cshowsPrec :: Int -> WindowWindowClass -> ShowS
Show, WindowWindowClass -> WindowWindowClass -> Bool
(WindowWindowClass -> WindowWindowClass -> Bool)
-> (WindowWindowClass -> WindowWindowClass -> Bool)
-> Eq WindowWindowClass
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: WindowWindowClass -> WindowWindowClass -> Bool
$c/= :: WindowWindowClass -> WindowWindowClass -> Bool
== :: WindowWindowClass -> WindowWindowClass -> Bool
$c== :: WindowWindowClass -> WindowWindowClass -> Bool
Eq)
instance P.Enum WindowWindowClass where
fromEnum :: WindowWindowClass -> Int
fromEnum WindowWindowClassInputOutput = 0
fromEnum WindowWindowClassInputOnly = 1
fromEnum (AnotherWindowWindowClass k :: Int
k) = Int
k
toEnum :: Int -> WindowWindowClass
toEnum 0 = WindowWindowClass
WindowWindowClassInputOutput
toEnum 1 = WindowWindowClass
WindowWindowClassInputOnly
toEnum k :: Int
k = Int -> WindowWindowClass
AnotherWindowWindowClass Int
k
instance P.Ord WindowWindowClass where
compare :: WindowWindowClass -> WindowWindowClass -> Ordering
compare a :: WindowWindowClass
a b :: WindowWindowClass
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (WindowWindowClass -> Int
forall a. Enum a => a -> Int
P.fromEnum WindowWindowClass
a) (WindowWindowClass -> Int
forall a. Enum a => a -> Int
P.fromEnum WindowWindowClass
b)
foreign import ccall "gdk_window_window_class_get_type" c_gdk_window_window_class_get_type ::
IO GType
instance BoxedEnum WindowWindowClass where
boxedEnumType :: WindowWindowClass -> IO GType
boxedEnumType _ = IO GType
c_gdk_window_window_class_get_type
data WindowTypeHint =
WindowTypeHintNormal
| WindowTypeHintDialog
|
| WindowTypeHintToolbar
| WindowTypeHintSplashscreen
| WindowTypeHintUtility
| WindowTypeHintDock
| WindowTypeHintDesktop
|
|
| WindowTypeHintTooltip
| WindowTypeHintNotification
| WindowTypeHintCombo
| WindowTypeHintDnd
| AnotherWindowTypeHint Int
deriving (Int -> WindowTypeHint -> ShowS
[WindowTypeHint] -> ShowS
WindowTypeHint -> String
(Int -> WindowTypeHint -> ShowS)
-> (WindowTypeHint -> String)
-> ([WindowTypeHint] -> ShowS)
-> Show WindowTypeHint
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [WindowTypeHint] -> ShowS
$cshowList :: [WindowTypeHint] -> ShowS
show :: WindowTypeHint -> String
$cshow :: WindowTypeHint -> String
showsPrec :: Int -> WindowTypeHint -> ShowS
$cshowsPrec :: Int -> WindowTypeHint -> ShowS
Show, WindowTypeHint -> WindowTypeHint -> Bool
(WindowTypeHint -> WindowTypeHint -> Bool)
-> (WindowTypeHint -> WindowTypeHint -> Bool) -> Eq WindowTypeHint
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: WindowTypeHint -> WindowTypeHint -> Bool
$c/= :: WindowTypeHint -> WindowTypeHint -> Bool
== :: WindowTypeHint -> WindowTypeHint -> Bool
$c== :: WindowTypeHint -> WindowTypeHint -> Bool
Eq)
instance P.Enum WindowTypeHint where
fromEnum :: WindowTypeHint -> Int
fromEnum WindowTypeHintNormal = 0
fromEnum WindowTypeHintDialog = 1
fromEnum WindowTypeHintMenu = 2
fromEnum WindowTypeHintToolbar = 3
fromEnum WindowTypeHintSplashscreen = 4
fromEnum WindowTypeHintUtility = 5
fromEnum WindowTypeHintDock = 6
fromEnum WindowTypeHintDesktop = 7
fromEnum WindowTypeHintDropdownMenu = 8
fromEnum WindowTypeHintPopupMenu = 9
fromEnum WindowTypeHintTooltip = 10
fromEnum WindowTypeHintNotification = 11
fromEnum WindowTypeHintCombo = 12
fromEnum WindowTypeHintDnd = 13
fromEnum (AnotherWindowTypeHint k :: Int
k) = Int
k
toEnum :: Int -> WindowTypeHint
toEnum 0 = WindowTypeHint
WindowTypeHintNormal
toEnum 1 = WindowTypeHint
WindowTypeHintDialog
toEnum 2 = WindowTypeHint
WindowTypeHintMenu
toEnum 3 = WindowTypeHint
WindowTypeHintToolbar
toEnum 4 = WindowTypeHint
WindowTypeHintSplashscreen
toEnum 5 = WindowTypeHint
WindowTypeHintUtility
toEnum 6 = WindowTypeHint
WindowTypeHintDock
toEnum 7 = WindowTypeHint
WindowTypeHintDesktop
toEnum 8 = WindowTypeHint
WindowTypeHintDropdownMenu
toEnum 9 = WindowTypeHint
WindowTypeHintPopupMenu
toEnum 10 = WindowTypeHint
WindowTypeHintTooltip
toEnum 11 = WindowTypeHint
WindowTypeHintNotification
toEnum 12 = WindowTypeHint
WindowTypeHintCombo
toEnum 13 = WindowTypeHint
WindowTypeHintDnd
toEnum k :: Int
k = Int -> WindowTypeHint
AnotherWindowTypeHint Int
k
instance P.Ord WindowTypeHint where
compare :: WindowTypeHint -> WindowTypeHint -> Ordering
compare a :: WindowTypeHint
a b :: WindowTypeHint
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (WindowTypeHint -> Int
forall a. Enum a => a -> Int
P.fromEnum WindowTypeHint
a) (WindowTypeHint -> Int
forall a. Enum a => a -> Int
P.fromEnum WindowTypeHint
b)
foreign import ccall "gdk_window_type_hint_get_type" c_gdk_window_type_hint_get_type ::
IO GType
instance BoxedEnum WindowTypeHint where
boxedEnumType :: WindowTypeHint -> IO GType
boxedEnumType _ = IO GType
c_gdk_window_type_hint_get_type
data WindowType =
WindowTypeRoot
| WindowTypeToplevel
| WindowTypeChild
| WindowTypeTemp
| WindowTypeForeign
| WindowTypeOffscreen
| WindowTypeSubsurface
| AnotherWindowType Int
deriving (Int -> WindowType -> ShowS
[WindowType] -> ShowS
WindowType -> String
(Int -> WindowType -> ShowS)
-> (WindowType -> String)
-> ([WindowType] -> ShowS)
-> Show WindowType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [WindowType] -> ShowS
$cshowList :: [WindowType] -> ShowS
show :: WindowType -> String
$cshow :: WindowType -> String
showsPrec :: Int -> WindowType -> ShowS
$cshowsPrec :: Int -> WindowType -> ShowS
Show, WindowType -> WindowType -> Bool
(WindowType -> WindowType -> Bool)
-> (WindowType -> WindowType -> Bool) -> Eq WindowType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: WindowType -> WindowType -> Bool
$c/= :: WindowType -> WindowType -> Bool
== :: WindowType -> WindowType -> Bool
$c== :: WindowType -> WindowType -> Bool
Eq)
instance P.Enum WindowType where
fromEnum :: WindowType -> Int
fromEnum WindowTypeRoot = 0
fromEnum WindowTypeToplevel = 1
fromEnum WindowTypeChild = 2
fromEnum WindowTypeTemp = 3
fromEnum WindowTypeForeign = 4
fromEnum WindowTypeOffscreen = 5
fromEnum WindowTypeSubsurface = 6
fromEnum (AnotherWindowType k :: Int
k) = Int
k
toEnum :: Int -> WindowType
toEnum 0 = WindowType
WindowTypeRoot
toEnum 1 = WindowType
WindowTypeToplevel
toEnum 2 = WindowType
WindowTypeChild
toEnum 3 = WindowType
WindowTypeTemp
toEnum 4 = WindowType
WindowTypeForeign
toEnum 5 = WindowType
WindowTypeOffscreen
toEnum 6 = WindowType
WindowTypeSubsurface
toEnum k :: Int
k = Int -> WindowType
AnotherWindowType Int
k
instance P.Ord WindowType where
compare :: WindowType -> WindowType -> Ordering
compare a :: WindowType
a b :: WindowType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (WindowType -> Int
forall a. Enum a => a -> Int
P.fromEnum WindowType
a) (WindowType -> Int
forall a. Enum a => a -> Int
P.fromEnum WindowType
b)
foreign import ccall "gdk_window_type_get_type" c_gdk_window_type_get_type ::
IO GType
instance BoxedEnum WindowType where
boxedEnumType :: WindowType -> IO GType
boxedEnumType _ = IO GType
c_gdk_window_type_get_type
data WindowEdge =
WindowEdgeNorthWest
| WindowEdgeNorth
| WindowEdgeNorthEast
| WindowEdgeWest
| WindowEdgeEast
| WindowEdgeSouthWest
| WindowEdgeSouth
| WindowEdgeSouthEast
| AnotherWindowEdge Int
deriving (Int -> WindowEdge -> ShowS
[WindowEdge] -> ShowS
WindowEdge -> String
(Int -> WindowEdge -> ShowS)
-> (WindowEdge -> String)
-> ([WindowEdge] -> ShowS)
-> Show WindowEdge
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [WindowEdge] -> ShowS
$cshowList :: [WindowEdge] -> ShowS
show :: WindowEdge -> String
$cshow :: WindowEdge -> String
showsPrec :: Int -> WindowEdge -> ShowS
$cshowsPrec :: Int -> WindowEdge -> ShowS
Show, WindowEdge -> WindowEdge -> Bool
(WindowEdge -> WindowEdge -> Bool)
-> (WindowEdge -> WindowEdge -> Bool) -> Eq WindowEdge
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: WindowEdge -> WindowEdge -> Bool
$c/= :: WindowEdge -> WindowEdge -> Bool
== :: WindowEdge -> WindowEdge -> Bool
$c== :: WindowEdge -> WindowEdge -> Bool
Eq)
instance P.Enum WindowEdge where
fromEnum :: WindowEdge -> Int
fromEnum WindowEdgeNorthWest = 0
fromEnum WindowEdgeNorth = 1
fromEnum WindowEdgeNorthEast = 2
fromEnum WindowEdgeWest = 3
fromEnum WindowEdgeEast = 4
fromEnum WindowEdgeSouthWest = 5
fromEnum WindowEdgeSouth = 6
fromEnum WindowEdgeSouthEast = 7
fromEnum (AnotherWindowEdge k :: Int
k) = Int
k
toEnum :: Int -> WindowEdge
toEnum 0 = WindowEdge
WindowEdgeNorthWest
toEnum 1 = WindowEdge
WindowEdgeNorth
toEnum 2 = WindowEdge
WindowEdgeNorthEast
toEnum 3 = WindowEdge
WindowEdgeWest
toEnum 4 = WindowEdge
WindowEdgeEast
toEnum 5 = WindowEdge
WindowEdgeSouthWest
toEnum 6 = WindowEdge
WindowEdgeSouth
toEnum 7 = WindowEdge
WindowEdgeSouthEast
toEnum k :: Int
k = Int -> WindowEdge
AnotherWindowEdge Int
k
instance P.Ord WindowEdge where
compare :: WindowEdge -> WindowEdge -> Ordering
compare a :: WindowEdge
a b :: WindowEdge
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (WindowEdge -> Int
forall a. Enum a => a -> Int
P.fromEnum WindowEdge
a) (WindowEdge -> Int
forall a. Enum a => a -> Int
P.fromEnum WindowEdge
b)
foreign import ccall "gdk_window_edge_get_type" c_gdk_window_edge_get_type ::
IO GType
instance BoxedEnum WindowEdge where
boxedEnumType :: WindowEdge -> IO GType
boxedEnumType _ = IO GType
c_gdk_window_edge_get_type
data VisualType =
VisualTypeStaticGray
| VisualTypeGrayscale
| VisualTypeStaticColor
| VisualTypePseudoColor
| VisualTypeTrueColor
| VisualTypeDirectColor
| AnotherVisualType Int
deriving (Int -> VisualType -> ShowS
[VisualType] -> ShowS
VisualType -> String
(Int -> VisualType -> ShowS)
-> (VisualType -> String)
-> ([VisualType] -> ShowS)
-> Show VisualType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VisualType] -> ShowS
$cshowList :: [VisualType] -> ShowS
show :: VisualType -> String
$cshow :: VisualType -> String
showsPrec :: Int -> VisualType -> ShowS
$cshowsPrec :: Int -> VisualType -> ShowS
Show, VisualType -> VisualType -> Bool
(VisualType -> VisualType -> Bool)
-> (VisualType -> VisualType -> Bool) -> Eq VisualType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VisualType -> VisualType -> Bool
$c/= :: VisualType -> VisualType -> Bool
== :: VisualType -> VisualType -> Bool
$c== :: VisualType -> VisualType -> Bool
Eq)
instance P.Enum VisualType where
fromEnum :: VisualType -> Int
fromEnum VisualTypeStaticGray = 0
fromEnum VisualTypeGrayscale = 1
fromEnum VisualTypeStaticColor = 2
fromEnum VisualTypePseudoColor = 3
fromEnum VisualTypeTrueColor = 4
fromEnum VisualTypeDirectColor = 5
fromEnum (AnotherVisualType k :: Int
k) = Int
k
toEnum :: Int -> VisualType
toEnum 0 = VisualType
VisualTypeStaticGray
toEnum 1 = VisualType
VisualTypeGrayscale
toEnum 2 = VisualType
VisualTypeStaticColor
toEnum 3 = VisualType
VisualTypePseudoColor
toEnum 4 = VisualType
VisualTypeTrueColor
toEnum 5 = VisualType
VisualTypeDirectColor
toEnum k :: Int
k = Int -> VisualType
AnotherVisualType Int
k
instance P.Ord VisualType where
compare :: VisualType -> VisualType -> Ordering
compare a :: VisualType
a b :: VisualType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (VisualType -> Int
forall a. Enum a => a -> Int
P.fromEnum VisualType
a) (VisualType -> Int
forall a. Enum a => a -> Int
P.fromEnum VisualType
b)
foreign import ccall "gdk_visual_type_get_type" c_gdk_visual_type_get_type ::
IO GType
instance BoxedEnum VisualType where
boxedEnumType :: VisualType -> IO GType
boxedEnumType _ = IO GType
c_gdk_visual_type_get_type
data VisibilityState =
VisibilityStateUnobscured
| VisibilityStatePartial
| VisibilityStateFullyObscured
| AnotherVisibilityState Int
deriving (Int -> VisibilityState -> ShowS
[VisibilityState] -> ShowS
VisibilityState -> String
(Int -> VisibilityState -> ShowS)
-> (VisibilityState -> String)
-> ([VisibilityState] -> ShowS)
-> Show VisibilityState
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VisibilityState] -> ShowS
$cshowList :: [VisibilityState] -> ShowS
show :: VisibilityState -> String
$cshow :: VisibilityState -> String
showsPrec :: Int -> VisibilityState -> ShowS
$cshowsPrec :: Int -> VisibilityState -> ShowS
Show, VisibilityState -> VisibilityState -> Bool
(VisibilityState -> VisibilityState -> Bool)
-> (VisibilityState -> VisibilityState -> Bool)
-> Eq VisibilityState
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VisibilityState -> VisibilityState -> Bool
$c/= :: VisibilityState -> VisibilityState -> Bool
== :: VisibilityState -> VisibilityState -> Bool
$c== :: VisibilityState -> VisibilityState -> Bool
Eq)
instance P.Enum VisibilityState where
fromEnum :: VisibilityState -> Int
fromEnum VisibilityStateUnobscured = 0
fromEnum VisibilityStatePartial = 1
fromEnum VisibilityStateFullyObscured = 2
fromEnum (AnotherVisibilityState k :: Int
k) = Int
k
toEnum :: Int -> VisibilityState
toEnum 0 = VisibilityState
VisibilityStateUnobscured
toEnum 1 = VisibilityState
VisibilityStatePartial
toEnum 2 = VisibilityState
VisibilityStateFullyObscured
toEnum k :: Int
k = Int -> VisibilityState
AnotherVisibilityState Int
k
instance P.Ord VisibilityState where
compare :: VisibilityState -> VisibilityState -> Ordering
compare a :: VisibilityState
a b :: VisibilityState
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (VisibilityState -> Int
forall a. Enum a => a -> Int
P.fromEnum VisibilityState
a) (VisibilityState -> Int
forall a. Enum a => a -> Int
P.fromEnum VisibilityState
b)
foreign import ccall "gdk_visibility_state_get_type" c_gdk_visibility_state_get_type ::
IO GType
instance BoxedEnum VisibilityState where
boxedEnumType :: VisibilityState -> IO GType
boxedEnumType _ = IO GType
c_gdk_visibility_state_get_type
data TouchpadGesturePhase =
TouchpadGesturePhaseBegin
| TouchpadGesturePhaseUpdate
| TouchpadGesturePhaseEnd
| TouchpadGesturePhaseCancel
| AnotherTouchpadGesturePhase Int
deriving (Int -> TouchpadGesturePhase -> ShowS
[TouchpadGesturePhase] -> ShowS
TouchpadGesturePhase -> String
(Int -> TouchpadGesturePhase -> ShowS)
-> (TouchpadGesturePhase -> String)
-> ([TouchpadGesturePhase] -> ShowS)
-> Show TouchpadGesturePhase
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TouchpadGesturePhase] -> ShowS
$cshowList :: [TouchpadGesturePhase] -> ShowS
show :: TouchpadGesturePhase -> String
$cshow :: TouchpadGesturePhase -> String
showsPrec :: Int -> TouchpadGesturePhase -> ShowS
$cshowsPrec :: Int -> TouchpadGesturePhase -> ShowS
Show, TouchpadGesturePhase -> TouchpadGesturePhase -> Bool
(TouchpadGesturePhase -> TouchpadGesturePhase -> Bool)
-> (TouchpadGesturePhase -> TouchpadGesturePhase -> Bool)
-> Eq TouchpadGesturePhase
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TouchpadGesturePhase -> TouchpadGesturePhase -> Bool
$c/= :: TouchpadGesturePhase -> TouchpadGesturePhase -> Bool
== :: TouchpadGesturePhase -> TouchpadGesturePhase -> Bool
$c== :: TouchpadGesturePhase -> TouchpadGesturePhase -> Bool
Eq)
instance P.Enum TouchpadGesturePhase where
fromEnum :: TouchpadGesturePhase -> Int
fromEnum TouchpadGesturePhaseBegin = 0
fromEnum TouchpadGesturePhaseUpdate = 1
fromEnum TouchpadGesturePhaseEnd = 2
fromEnum TouchpadGesturePhaseCancel = 3
fromEnum (AnotherTouchpadGesturePhase k :: Int
k) = Int
k
toEnum :: Int -> TouchpadGesturePhase
toEnum 0 = TouchpadGesturePhase
TouchpadGesturePhaseBegin
toEnum 1 = TouchpadGesturePhase
TouchpadGesturePhaseUpdate
toEnum 2 = TouchpadGesturePhase
TouchpadGesturePhaseEnd
toEnum 3 = TouchpadGesturePhase
TouchpadGesturePhaseCancel
toEnum k :: Int
k = Int -> TouchpadGesturePhase
AnotherTouchpadGesturePhase Int
k
instance P.Ord TouchpadGesturePhase where
compare :: TouchpadGesturePhase -> TouchpadGesturePhase -> Ordering
compare a :: TouchpadGesturePhase
a b :: TouchpadGesturePhase
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (TouchpadGesturePhase -> Int
forall a. Enum a => a -> Int
P.fromEnum TouchpadGesturePhase
a) (TouchpadGesturePhase -> Int
forall a. Enum a => a -> Int
P.fromEnum TouchpadGesturePhase
b)
foreign import ccall "gdk_touchpad_gesture_phase_get_type" c_gdk_touchpad_gesture_phase_get_type ::
IO GType
instance BoxedEnum TouchpadGesturePhase where
boxedEnumType :: TouchpadGesturePhase -> IO GType
boxedEnumType _ = IO GType
c_gdk_touchpad_gesture_phase_get_type
data SubpixelLayout =
SubpixelLayoutUnknown
| SubpixelLayoutNone
| SubpixelLayoutHorizontalRgb
| SubpixelLayoutHorizontalBgr
| SubpixelLayoutVerticalRgb
| SubpixelLayoutVerticalBgr
| AnotherSubpixelLayout Int
deriving (Int -> SubpixelLayout -> ShowS
[SubpixelLayout] -> ShowS
SubpixelLayout -> String
(Int -> SubpixelLayout -> ShowS)
-> (SubpixelLayout -> String)
-> ([SubpixelLayout] -> ShowS)
-> Show SubpixelLayout
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SubpixelLayout] -> ShowS
$cshowList :: [SubpixelLayout] -> ShowS
show :: SubpixelLayout -> String
$cshow :: SubpixelLayout -> String
showsPrec :: Int -> SubpixelLayout -> ShowS
$cshowsPrec :: Int -> SubpixelLayout -> ShowS
Show, SubpixelLayout -> SubpixelLayout -> Bool
(SubpixelLayout -> SubpixelLayout -> Bool)
-> (SubpixelLayout -> SubpixelLayout -> Bool) -> Eq SubpixelLayout
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SubpixelLayout -> SubpixelLayout -> Bool
$c/= :: SubpixelLayout -> SubpixelLayout -> Bool
== :: SubpixelLayout -> SubpixelLayout -> Bool
$c== :: SubpixelLayout -> SubpixelLayout -> Bool
Eq)
instance P.Enum SubpixelLayout where
fromEnum :: SubpixelLayout -> Int
fromEnum SubpixelLayoutUnknown = 0
fromEnum SubpixelLayoutNone = 1
fromEnum SubpixelLayoutHorizontalRgb = 2
fromEnum SubpixelLayoutHorizontalBgr = 3
fromEnum SubpixelLayoutVerticalRgb = 4
fromEnum SubpixelLayoutVerticalBgr = 5
fromEnum (AnotherSubpixelLayout k :: Int
k) = Int
k
toEnum :: Int -> SubpixelLayout
toEnum 0 = SubpixelLayout
SubpixelLayoutUnknown
toEnum 1 = SubpixelLayout
SubpixelLayoutNone
toEnum 2 = SubpixelLayout
SubpixelLayoutHorizontalRgb
toEnum 3 = SubpixelLayout
SubpixelLayoutHorizontalBgr
toEnum 4 = SubpixelLayout
SubpixelLayoutVerticalRgb
toEnum 5 = SubpixelLayout
SubpixelLayoutVerticalBgr
toEnum k :: Int
k = Int -> SubpixelLayout
AnotherSubpixelLayout Int
k
instance P.Ord SubpixelLayout where
compare :: SubpixelLayout -> SubpixelLayout -> Ordering
compare a :: SubpixelLayout
a b :: SubpixelLayout
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SubpixelLayout -> Int
forall a. Enum a => a -> Int
P.fromEnum SubpixelLayout
a) (SubpixelLayout -> Int
forall a. Enum a => a -> Int
P.fromEnum SubpixelLayout
b)
foreign import ccall "gdk_subpixel_layout_get_type" c_gdk_subpixel_layout_get_type ::
IO GType
instance BoxedEnum SubpixelLayout where
boxedEnumType :: SubpixelLayout -> IO GType
boxedEnumType _ = IO GType
c_gdk_subpixel_layout_get_type
data Status =
StatusOk
| StatusError
| StatusErrorParam
| StatusErrorFile
| StatusErrorMem
| AnotherStatus Int
deriving (Int -> Status -> ShowS
[Status] -> ShowS
Status -> String
(Int -> Status -> ShowS)
-> (Status -> String) -> ([Status] -> ShowS) -> Show Status
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Status] -> ShowS
$cshowList :: [Status] -> ShowS
show :: Status -> String
$cshow :: Status -> String
showsPrec :: Int -> Status -> ShowS
$cshowsPrec :: Int -> Status -> ShowS
Show, Status -> Status -> Bool
(Status -> Status -> Bool)
-> (Status -> Status -> Bool) -> Eq Status
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Status -> Status -> Bool
$c/= :: Status -> Status -> Bool
== :: Status -> Status -> Bool
$c== :: Status -> Status -> Bool
Eq)
instance P.Enum Status where
fromEnum :: Status -> Int
fromEnum StatusOk = 0
fromEnum StatusError = -1
fromEnum StatusErrorParam = -2
fromEnum StatusErrorFile = -3
fromEnum StatusErrorMem = -4
fromEnum (AnotherStatus k :: Int
k) = Int
k
toEnum :: Int -> Status
toEnum 0 = Status
StatusOk
toEnum -1 = Status
StatusError
toEnum -2 = Status
StatusErrorParam
toEnum -3 = Status
StatusErrorFile
toEnum -4 = Status
StatusErrorMem
toEnum k :: Int
k = Int -> Status
AnotherStatus Int
k
instance P.Ord Status where
compare :: Status -> Status -> Ordering
compare a :: Status
a b :: Status
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (Status -> Int
forall a. Enum a => a -> Int
P.fromEnum Status
a) (Status -> Int
forall a. Enum a => a -> Int
P.fromEnum Status
b)
foreign import ccall "gdk_status_get_type" c_gdk_status_get_type ::
IO GType
instance BoxedEnum Status where
boxedEnumType :: Status -> IO GType
boxedEnumType _ = IO GType
c_gdk_status_get_type
data SettingAction =
SettingActionNew
| SettingActionChanged
| SettingActionDeleted
| AnotherSettingAction Int
deriving (Int -> SettingAction -> ShowS
[SettingAction] -> ShowS
SettingAction -> String
(Int -> SettingAction -> ShowS)
-> (SettingAction -> String)
-> ([SettingAction] -> ShowS)
-> Show SettingAction
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SettingAction] -> ShowS
$cshowList :: [SettingAction] -> ShowS
show :: SettingAction -> String
$cshow :: SettingAction -> String
showsPrec :: Int -> SettingAction -> ShowS
$cshowsPrec :: Int -> SettingAction -> ShowS
Show, SettingAction -> SettingAction -> Bool
(SettingAction -> SettingAction -> Bool)
-> (SettingAction -> SettingAction -> Bool) -> Eq SettingAction
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SettingAction -> SettingAction -> Bool
$c/= :: SettingAction -> SettingAction -> Bool
== :: SettingAction -> SettingAction -> Bool
$c== :: SettingAction -> SettingAction -> Bool
Eq)
instance P.Enum SettingAction where
fromEnum :: SettingAction -> Int
fromEnum SettingActionNew = 0
fromEnum SettingActionChanged = 1
fromEnum SettingActionDeleted = 2
fromEnum (AnotherSettingAction k :: Int
k) = Int
k
toEnum :: Int -> SettingAction
toEnum 0 = SettingAction
SettingActionNew
toEnum 1 = SettingAction
SettingActionChanged
toEnum 2 = SettingAction
SettingActionDeleted
toEnum k :: Int
k = Int -> SettingAction
AnotherSettingAction Int
k
instance P.Ord SettingAction where
compare :: SettingAction -> SettingAction -> Ordering
compare a :: SettingAction
a b :: SettingAction
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SettingAction -> Int
forall a. Enum a => a -> Int
P.fromEnum SettingAction
a) (SettingAction -> Int
forall a. Enum a => a -> Int
P.fromEnum SettingAction
b)
foreign import ccall "gdk_setting_action_get_type" c_gdk_setting_action_get_type ::
IO GType
instance BoxedEnum SettingAction where
boxedEnumType :: SettingAction -> IO GType
boxedEnumType _ = IO GType
c_gdk_setting_action_get_type
data ScrollDirection =
ScrollDirectionUp
| ScrollDirectionDown
| ScrollDirectionLeft
| ScrollDirectionRight
| ScrollDirectionSmooth
| AnotherScrollDirection Int
deriving (Int -> ScrollDirection -> ShowS
[ScrollDirection] -> ShowS
ScrollDirection -> String
(Int -> ScrollDirection -> ShowS)
-> (ScrollDirection -> String)
-> ([ScrollDirection] -> ShowS)
-> Show ScrollDirection
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ScrollDirection] -> ShowS
$cshowList :: [ScrollDirection] -> ShowS
show :: ScrollDirection -> String
$cshow :: ScrollDirection -> String
showsPrec :: Int -> ScrollDirection -> ShowS
$cshowsPrec :: Int -> ScrollDirection -> ShowS
Show, ScrollDirection -> ScrollDirection -> Bool
(ScrollDirection -> ScrollDirection -> Bool)
-> (ScrollDirection -> ScrollDirection -> Bool)
-> Eq ScrollDirection
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ScrollDirection -> ScrollDirection -> Bool
$c/= :: ScrollDirection -> ScrollDirection -> Bool
== :: ScrollDirection -> ScrollDirection -> Bool
$c== :: ScrollDirection -> ScrollDirection -> Bool
Eq)
instance P.Enum ScrollDirection where
fromEnum :: ScrollDirection -> Int
fromEnum ScrollDirectionUp = 0
fromEnum ScrollDirectionDown = 1
fromEnum ScrollDirectionLeft = 2
fromEnum ScrollDirectionRight = 3
fromEnum ScrollDirectionSmooth = 4
fromEnum (AnotherScrollDirection k :: Int
k) = Int
k
toEnum :: Int -> ScrollDirection
toEnum 0 = ScrollDirection
ScrollDirectionUp
toEnum 1 = ScrollDirection
ScrollDirectionDown
toEnum 2 = ScrollDirection
ScrollDirectionLeft
toEnum 3 = ScrollDirection
ScrollDirectionRight
toEnum 4 = ScrollDirection
ScrollDirectionSmooth
toEnum k :: Int
k = Int -> ScrollDirection
AnotherScrollDirection Int
k
instance P.Ord ScrollDirection where
compare :: ScrollDirection -> ScrollDirection -> Ordering
compare a :: ScrollDirection
a b :: ScrollDirection
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ScrollDirection -> Int
forall a. Enum a => a -> Int
P.fromEnum ScrollDirection
a) (ScrollDirection -> Int
forall a. Enum a => a -> Int
P.fromEnum ScrollDirection
b)
foreign import ccall "gdk_scroll_direction_get_type" c_gdk_scroll_direction_get_type ::
IO GType
instance BoxedEnum ScrollDirection where
boxedEnumType :: ScrollDirection -> IO GType
boxedEnumType _ = IO GType
c_gdk_scroll_direction_get_type
data PropertyState =
PropertyStateNewValue
| PropertyStateDelete
| AnotherPropertyState Int
deriving (Int -> PropertyState -> ShowS
[PropertyState] -> ShowS
PropertyState -> String
(Int -> PropertyState -> ShowS)
-> (PropertyState -> String)
-> ([PropertyState] -> ShowS)
-> Show PropertyState
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PropertyState] -> ShowS
$cshowList :: [PropertyState] -> ShowS
show :: PropertyState -> String
$cshow :: PropertyState -> String
showsPrec :: Int -> PropertyState -> ShowS
$cshowsPrec :: Int -> PropertyState -> ShowS
Show, PropertyState -> PropertyState -> Bool
(PropertyState -> PropertyState -> Bool)
-> (PropertyState -> PropertyState -> Bool) -> Eq PropertyState
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PropertyState -> PropertyState -> Bool
$c/= :: PropertyState -> PropertyState -> Bool
== :: PropertyState -> PropertyState -> Bool
$c== :: PropertyState -> PropertyState -> Bool
Eq)
instance P.Enum PropertyState where
fromEnum :: PropertyState -> Int
fromEnum PropertyStateNewValue = 0
fromEnum PropertyStateDelete = 1
fromEnum (AnotherPropertyState k :: Int
k) = Int
k
toEnum :: Int -> PropertyState
toEnum 0 = PropertyState
PropertyStateNewValue
toEnum 1 = PropertyState
PropertyStateDelete
toEnum k :: Int
k = Int -> PropertyState
AnotherPropertyState Int
k
instance P.Ord PropertyState where
compare :: PropertyState -> PropertyState -> Ordering
compare a :: PropertyState
a b :: PropertyState
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PropertyState -> Int
forall a. Enum a => a -> Int
P.fromEnum PropertyState
a) (PropertyState -> Int
forall a. Enum a => a -> Int
P.fromEnum PropertyState
b)
foreign import ccall "gdk_property_state_get_type" c_gdk_property_state_get_type ::
IO GType
instance BoxedEnum PropertyState where
boxedEnumType :: PropertyState -> IO GType
boxedEnumType _ = IO GType
c_gdk_property_state_get_type
data PropMode =
PropModeReplace
| PropModePrepend
| PropModeAppend
| AnotherPropMode Int
deriving (Int -> PropMode -> ShowS
[PropMode] -> ShowS
PropMode -> String
(Int -> PropMode -> ShowS)
-> (PropMode -> String) -> ([PropMode] -> ShowS) -> Show PropMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PropMode] -> ShowS
$cshowList :: [PropMode] -> ShowS
show :: PropMode -> String
$cshow :: PropMode -> String
showsPrec :: Int -> PropMode -> ShowS
$cshowsPrec :: Int -> PropMode -> ShowS
Show, PropMode -> PropMode -> Bool
(PropMode -> PropMode -> Bool)
-> (PropMode -> PropMode -> Bool) -> Eq PropMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PropMode -> PropMode -> Bool
$c/= :: PropMode -> PropMode -> Bool
== :: PropMode -> PropMode -> Bool
$c== :: PropMode -> PropMode -> Bool
Eq)
instance P.Enum PropMode where
fromEnum :: PropMode -> Int
fromEnum PropModeReplace = 0
fromEnum PropModePrepend = 1
fromEnum PropModeAppend = 2
fromEnum (AnotherPropMode k :: Int
k) = Int
k
toEnum :: Int -> PropMode
toEnum 0 = PropMode
PropModeReplace
toEnum 1 = PropMode
PropModePrepend
toEnum 2 = PropMode
PropModeAppend
toEnum k :: Int
k = Int -> PropMode
AnotherPropMode Int
k
instance P.Ord PropMode where
compare :: PropMode -> PropMode -> Ordering
compare a :: PropMode
a b :: PropMode
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PropMode -> Int
forall a. Enum a => a -> Int
P.fromEnum PropMode
a) (PropMode -> Int
forall a. Enum a => a -> Int
P.fromEnum PropMode
b)
foreign import ccall "gdk_prop_mode_get_type" c_gdk_prop_mode_get_type ::
IO GType
instance BoxedEnum PropMode where
boxedEnumType :: PropMode -> IO GType
boxedEnumType _ = IO GType
c_gdk_prop_mode_get_type
data OwnerChange =
OwnerChangeNewOwner
| OwnerChangeDestroy
| OwnerChangeClose
| AnotherOwnerChange Int
deriving (Int -> OwnerChange -> ShowS
[OwnerChange] -> ShowS
OwnerChange -> String
(Int -> OwnerChange -> ShowS)
-> (OwnerChange -> String)
-> ([OwnerChange] -> ShowS)
-> Show OwnerChange
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [OwnerChange] -> ShowS
$cshowList :: [OwnerChange] -> ShowS
show :: OwnerChange -> String
$cshow :: OwnerChange -> String
showsPrec :: Int -> OwnerChange -> ShowS
$cshowsPrec :: Int -> OwnerChange -> ShowS
Show, OwnerChange -> OwnerChange -> Bool
(OwnerChange -> OwnerChange -> Bool)
-> (OwnerChange -> OwnerChange -> Bool) -> Eq OwnerChange
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: OwnerChange -> OwnerChange -> Bool
$c/= :: OwnerChange -> OwnerChange -> Bool
== :: OwnerChange -> OwnerChange -> Bool
$c== :: OwnerChange -> OwnerChange -> Bool
Eq)
instance P.Enum OwnerChange where
fromEnum :: OwnerChange -> Int
fromEnum OwnerChangeNewOwner = 0
fromEnum OwnerChangeDestroy = 1
fromEnum OwnerChangeClose = 2
fromEnum (AnotherOwnerChange k :: Int
k) = Int
k
toEnum :: Int -> OwnerChange
toEnum 0 = OwnerChange
OwnerChangeNewOwner
toEnum 1 = OwnerChange
OwnerChangeDestroy
toEnum 2 = OwnerChange
OwnerChangeClose
toEnum k :: Int
k = Int -> OwnerChange
AnotherOwnerChange Int
k
instance P.Ord OwnerChange where
compare :: OwnerChange -> OwnerChange -> Ordering
compare a :: OwnerChange
a b :: OwnerChange
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (OwnerChange -> Int
forall a. Enum a => a -> Int
P.fromEnum OwnerChange
a) (OwnerChange -> Int
forall a. Enum a => a -> Int
P.fromEnum OwnerChange
b)
foreign import ccall "gdk_owner_change_get_type" c_gdk_owner_change_get_type ::
IO GType
instance BoxedEnum OwnerChange where
boxedEnumType :: OwnerChange -> IO GType
boxedEnumType _ = IO GType
c_gdk_owner_change_get_type
data NotifyType =
NotifyTypeAncestor
| NotifyTypeVirtual
| NotifyTypeInferior
| NotifyTypeNonlinear
| NotifyTypeNonlinearVirtual
| NotifyTypeUnknown
| AnotherNotifyType Int
deriving (Int -> NotifyType -> ShowS
[NotifyType] -> ShowS
NotifyType -> String
(Int -> NotifyType -> ShowS)
-> (NotifyType -> String)
-> ([NotifyType] -> ShowS)
-> Show NotifyType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NotifyType] -> ShowS
$cshowList :: [NotifyType] -> ShowS
show :: NotifyType -> String
$cshow :: NotifyType -> String
showsPrec :: Int -> NotifyType -> ShowS
$cshowsPrec :: Int -> NotifyType -> ShowS
Show, NotifyType -> NotifyType -> Bool
(NotifyType -> NotifyType -> Bool)
-> (NotifyType -> NotifyType -> Bool) -> Eq NotifyType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NotifyType -> NotifyType -> Bool
$c/= :: NotifyType -> NotifyType -> Bool
== :: NotifyType -> NotifyType -> Bool
$c== :: NotifyType -> NotifyType -> Bool
Eq)
instance P.Enum NotifyType where
fromEnum :: NotifyType -> Int
fromEnum NotifyTypeAncestor = 0
fromEnum NotifyTypeVirtual = 1
fromEnum NotifyTypeInferior = 2
fromEnum NotifyTypeNonlinear = 3
fromEnum NotifyTypeNonlinearVirtual = 4
fromEnum NotifyTypeUnknown = 5
fromEnum (AnotherNotifyType k :: Int
k) = Int
k
toEnum :: Int -> NotifyType
toEnum 0 = NotifyType
NotifyTypeAncestor
toEnum 1 = NotifyType
NotifyTypeVirtual
toEnum 2 = NotifyType
NotifyTypeInferior
toEnum 3 = NotifyType
NotifyTypeNonlinear
toEnum 4 = NotifyType
NotifyTypeNonlinearVirtual
toEnum 5 = NotifyType
NotifyTypeUnknown
toEnum k :: Int
k = Int -> NotifyType
AnotherNotifyType Int
k
instance P.Ord NotifyType where
compare :: NotifyType -> NotifyType -> Ordering
compare a :: NotifyType
a b :: NotifyType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (NotifyType -> Int
forall a. Enum a => a -> Int
P.fromEnum NotifyType
a) (NotifyType -> Int
forall a. Enum a => a -> Int
P.fromEnum NotifyType
b)
foreign import ccall "gdk_notify_type_get_type" c_gdk_notify_type_get_type ::
IO GType
instance BoxedEnum NotifyType where
boxedEnumType :: NotifyType -> IO GType
boxedEnumType _ = IO GType
c_gdk_notify_type_get_type
data ModifierIntent =
ModifierIntentPrimaryAccelerator
|
| ModifierIntentExtendSelection
| ModifierIntentModifySelection
| ModifierIntentNoTextInput
| ModifierIntentShiftGroup
| ModifierIntentDefaultModMask
| AnotherModifierIntent Int
deriving (Int -> ModifierIntent -> ShowS
[ModifierIntent] -> ShowS
ModifierIntent -> String
(Int -> ModifierIntent -> ShowS)
-> (ModifierIntent -> String)
-> ([ModifierIntent] -> ShowS)
-> Show ModifierIntent
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ModifierIntent] -> ShowS
$cshowList :: [ModifierIntent] -> ShowS
show :: ModifierIntent -> String
$cshow :: ModifierIntent -> String
showsPrec :: Int -> ModifierIntent -> ShowS
$cshowsPrec :: Int -> ModifierIntent -> ShowS
Show, ModifierIntent -> ModifierIntent -> Bool
(ModifierIntent -> ModifierIntent -> Bool)
-> (ModifierIntent -> ModifierIntent -> Bool) -> Eq ModifierIntent
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ModifierIntent -> ModifierIntent -> Bool
$c/= :: ModifierIntent -> ModifierIntent -> Bool
== :: ModifierIntent -> ModifierIntent -> Bool
$c== :: ModifierIntent -> ModifierIntent -> Bool
Eq)
instance P.Enum ModifierIntent where
fromEnum :: ModifierIntent -> Int
fromEnum ModifierIntentPrimaryAccelerator = 0
fromEnum ModifierIntentContextMenu = 1
fromEnum ModifierIntentExtendSelection = 2
fromEnum ModifierIntentModifySelection = 3
fromEnum ModifierIntentNoTextInput = 4
fromEnum ModifierIntentShiftGroup = 5
fromEnum ModifierIntentDefaultModMask = 6
fromEnum (AnotherModifierIntent k :: Int
k) = Int
k
toEnum :: Int -> ModifierIntent
toEnum 0 = ModifierIntent
ModifierIntentPrimaryAccelerator
toEnum 1 = ModifierIntent
ModifierIntentContextMenu
toEnum 2 = ModifierIntent
ModifierIntentExtendSelection
toEnum 3 = ModifierIntent
ModifierIntentModifySelection
toEnum 4 = ModifierIntent
ModifierIntentNoTextInput
toEnum 5 = ModifierIntent
ModifierIntentShiftGroup
toEnum 6 = ModifierIntent
ModifierIntentDefaultModMask
toEnum k :: Int
k = Int -> ModifierIntent
AnotherModifierIntent Int
k
instance P.Ord ModifierIntent where
compare :: ModifierIntent -> ModifierIntent -> Ordering
compare a :: ModifierIntent
a b :: ModifierIntent
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ModifierIntent -> Int
forall a. Enum a => a -> Int
P.fromEnum ModifierIntent
a) (ModifierIntent -> Int
forall a. Enum a => a -> Int
P.fromEnum ModifierIntent
b)
foreign import ccall "gdk_modifier_intent_get_type" c_gdk_modifier_intent_get_type ::
IO GType
instance BoxedEnum ModifierIntent where
boxedEnumType :: ModifierIntent -> IO GType
boxedEnumType _ = IO GType
c_gdk_modifier_intent_get_type
data InputSource =
InputSourceMouse
| InputSourcePen
| InputSourceEraser
| InputSourceCursor
| InputSourceKeyboard
| InputSourceTouchscreen
| InputSourceTouchpad
| InputSourceTrackpoint
| InputSourceTabletPad
| AnotherInputSource Int
deriving (Int -> InputSource -> ShowS
[InputSource] -> ShowS
InputSource -> String
(Int -> InputSource -> ShowS)
-> (InputSource -> String)
-> ([InputSource] -> ShowS)
-> Show InputSource
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [InputSource] -> ShowS
$cshowList :: [InputSource] -> ShowS
show :: InputSource -> String
$cshow :: InputSource -> String
showsPrec :: Int -> InputSource -> ShowS
$cshowsPrec :: Int -> InputSource -> ShowS
Show, InputSource -> InputSource -> Bool
(InputSource -> InputSource -> Bool)
-> (InputSource -> InputSource -> Bool) -> Eq InputSource
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: InputSource -> InputSource -> Bool
$c/= :: InputSource -> InputSource -> Bool
== :: InputSource -> InputSource -> Bool
$c== :: InputSource -> InputSource -> Bool
Eq)
instance P.Enum InputSource where
fromEnum :: InputSource -> Int
fromEnum InputSourceMouse = 0
fromEnum InputSourcePen = 1
fromEnum InputSourceEraser = 2
fromEnum InputSourceCursor = 3
fromEnum InputSourceKeyboard = 4
fromEnum InputSourceTouchscreen = 5
fromEnum InputSourceTouchpad = 6
fromEnum InputSourceTrackpoint = 7
fromEnum InputSourceTabletPad = 8
fromEnum (AnotherInputSource k :: Int
k) = Int
k
toEnum :: Int -> InputSource
toEnum 0 = InputSource
InputSourceMouse
toEnum 1 = InputSource
InputSourcePen
toEnum 2 = InputSource
InputSourceEraser
toEnum 3 = InputSource
InputSourceCursor
toEnum 4 = InputSource
InputSourceKeyboard
toEnum 5 = InputSource
InputSourceTouchscreen
toEnum 6 = InputSource
InputSourceTouchpad
toEnum 7 = InputSource
InputSourceTrackpoint
toEnum 8 = InputSource
InputSourceTabletPad
toEnum k :: Int
k = Int -> InputSource
AnotherInputSource Int
k
instance P.Ord InputSource where
compare :: InputSource -> InputSource -> Ordering
compare a :: InputSource
a b :: InputSource
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (InputSource -> Int
forall a. Enum a => a -> Int
P.fromEnum InputSource
a) (InputSource -> Int
forall a. Enum a => a -> Int
P.fromEnum InputSource
b)
foreign import ccall "gdk_input_source_get_type" c_gdk_input_source_get_type ::
IO GType
instance BoxedEnum InputSource where
boxedEnumType :: InputSource -> IO GType
boxedEnumType _ = IO GType
c_gdk_input_source_get_type
data InputMode =
InputModeDisabled
| InputModeScreen
| InputModeWindow
| AnotherInputMode Int
deriving (Int -> InputMode -> ShowS
[InputMode] -> ShowS
InputMode -> String
(Int -> InputMode -> ShowS)
-> (InputMode -> String)
-> ([InputMode] -> ShowS)
-> Show InputMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [InputMode] -> ShowS
$cshowList :: [InputMode] -> ShowS
show :: InputMode -> String
$cshow :: InputMode -> String
showsPrec :: Int -> InputMode -> ShowS
$cshowsPrec :: Int -> InputMode -> ShowS
Show, InputMode -> InputMode -> Bool
(InputMode -> InputMode -> Bool)
-> (InputMode -> InputMode -> Bool) -> Eq InputMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: InputMode -> InputMode -> Bool
$c/= :: InputMode -> InputMode -> Bool
== :: InputMode -> InputMode -> Bool
$c== :: InputMode -> InputMode -> Bool
Eq)
instance P.Enum InputMode where
fromEnum :: InputMode -> Int
fromEnum InputModeDisabled = 0
fromEnum InputModeScreen = 1
fromEnum InputModeWindow = 2
fromEnum (AnotherInputMode k :: Int
k) = Int
k
toEnum :: Int -> InputMode
toEnum 0 = InputMode
InputModeDisabled
toEnum 1 = InputMode
InputModeScreen
toEnum 2 = InputMode
InputModeWindow
toEnum k :: Int
k = Int -> InputMode
AnotherInputMode Int
k
instance P.Ord InputMode where
compare :: InputMode -> InputMode -> Ordering
compare a :: InputMode
a b :: InputMode
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (InputMode -> Int
forall a. Enum a => a -> Int
P.fromEnum InputMode
a) (InputMode -> Int
forall a. Enum a => a -> Int
P.fromEnum InputMode
b)
foreign import ccall "gdk_input_mode_get_type" c_gdk_input_mode_get_type ::
IO GType
instance BoxedEnum InputMode where
boxedEnumType :: InputMode -> IO GType
boxedEnumType _ = IO GType
c_gdk_input_mode_get_type
data Gravity =
GravityNorthWest
| GravityNorth
| GravityNorthEast
| GravityWest
| GravityCenter
| GravityEast
| GravitySouthWest
| GravitySouth
| GravitySouthEast
| GravityStatic
| AnotherGravity Int
deriving (Int -> Gravity -> ShowS
[Gravity] -> ShowS
Gravity -> String
(Int -> Gravity -> ShowS)
-> (Gravity -> String) -> ([Gravity] -> ShowS) -> Show Gravity
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Gravity] -> ShowS
$cshowList :: [Gravity] -> ShowS
show :: Gravity -> String
$cshow :: Gravity -> String
showsPrec :: Int -> Gravity -> ShowS
$cshowsPrec :: Int -> Gravity -> ShowS
Show, Gravity -> Gravity -> Bool
(Gravity -> Gravity -> Bool)
-> (Gravity -> Gravity -> Bool) -> Eq Gravity
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Gravity -> Gravity -> Bool
$c/= :: Gravity -> Gravity -> Bool
== :: Gravity -> Gravity -> Bool
$c== :: Gravity -> Gravity -> Bool
Eq)
instance P.Enum Gravity where
fromEnum :: Gravity -> Int
fromEnum GravityNorthWest = 1
fromEnum GravityNorth = 2
fromEnum GravityNorthEast = 3
fromEnum GravityWest = 4
fromEnum GravityCenter = 5
fromEnum GravityEast = 6
fromEnum GravitySouthWest = 7
fromEnum GravitySouth = 8
fromEnum GravitySouthEast = 9
fromEnum GravityStatic = 10
fromEnum (AnotherGravity k :: Int
k) = Int
k
toEnum :: Int -> Gravity
toEnum 1 = Gravity
GravityNorthWest
toEnum 2 = Gravity
GravityNorth
toEnum 3 = Gravity
GravityNorthEast
toEnum 4 = Gravity
GravityWest
toEnum 5 = Gravity
GravityCenter
toEnum 6 = Gravity
GravityEast
toEnum 7 = Gravity
GravitySouthWest
toEnum 8 = Gravity
GravitySouth
toEnum 9 = Gravity
GravitySouthEast
toEnum 10 = Gravity
GravityStatic
toEnum k :: Int
k = Int -> Gravity
AnotherGravity Int
k
instance P.Ord Gravity where
compare :: Gravity -> Gravity -> Ordering
compare a :: Gravity
a b :: Gravity
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (Gravity -> Int
forall a. Enum a => a -> Int
P.fromEnum Gravity
a) (Gravity -> Int
forall a. Enum a => a -> Int
P.fromEnum Gravity
b)
foreign import ccall "gdk_gravity_get_type" c_gdk_gravity_get_type ::
IO GType
instance BoxedEnum Gravity where
boxedEnumType :: Gravity -> IO GType
boxedEnumType _ = IO GType
c_gdk_gravity_get_type
data GrabStatus =
GrabStatusSuccess
| GrabStatusAlreadyGrabbed
| GrabStatusInvalidTime
| GrabStatusNotViewable
| GrabStatusFrozen
| GrabStatusFailed
| AnotherGrabStatus Int
deriving (Int -> GrabStatus -> ShowS
[GrabStatus] -> ShowS
GrabStatus -> String
(Int -> GrabStatus -> ShowS)
-> (GrabStatus -> String)
-> ([GrabStatus] -> ShowS)
-> Show GrabStatus
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GrabStatus] -> ShowS
$cshowList :: [GrabStatus] -> ShowS
show :: GrabStatus -> String
$cshow :: GrabStatus -> String
showsPrec :: Int -> GrabStatus -> ShowS
$cshowsPrec :: Int -> GrabStatus -> ShowS
Show, GrabStatus -> GrabStatus -> Bool
(GrabStatus -> GrabStatus -> Bool)
-> (GrabStatus -> GrabStatus -> Bool) -> Eq GrabStatus
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GrabStatus -> GrabStatus -> Bool
$c/= :: GrabStatus -> GrabStatus -> Bool
== :: GrabStatus -> GrabStatus -> Bool
$c== :: GrabStatus -> GrabStatus -> Bool
Eq)
instance P.Enum GrabStatus where
fromEnum :: GrabStatus -> Int
fromEnum GrabStatusSuccess = 0
fromEnum GrabStatusAlreadyGrabbed = 1
fromEnum GrabStatusInvalidTime = 2
fromEnum GrabStatusNotViewable = 3
fromEnum GrabStatusFrozen = 4
fromEnum GrabStatusFailed = 5
fromEnum (AnotherGrabStatus k :: Int
k) = Int
k
toEnum :: Int -> GrabStatus
toEnum 0 = GrabStatus
GrabStatusSuccess
toEnum 1 = GrabStatus
GrabStatusAlreadyGrabbed
toEnum 2 = GrabStatus
GrabStatusInvalidTime
toEnum 3 = GrabStatus
GrabStatusNotViewable
toEnum 4 = GrabStatus
GrabStatusFrozen
toEnum 5 = GrabStatus
GrabStatusFailed
toEnum k :: Int
k = Int -> GrabStatus
AnotherGrabStatus Int
k
instance P.Ord GrabStatus where
compare :: GrabStatus -> GrabStatus -> Ordering
compare a :: GrabStatus
a b :: GrabStatus
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (GrabStatus -> Int
forall a. Enum a => a -> Int
P.fromEnum GrabStatus
a) (GrabStatus -> Int
forall a. Enum a => a -> Int
P.fromEnum GrabStatus
b)
foreign import ccall "gdk_grab_status_get_type" c_gdk_grab_status_get_type ::
IO GType
instance BoxedEnum GrabStatus where
boxedEnumType :: GrabStatus -> IO GType
boxedEnumType _ = IO GType
c_gdk_grab_status_get_type
data GrabOwnership =
GrabOwnershipNone
| GrabOwnershipWindow
| GrabOwnershipApplication
| AnotherGrabOwnership Int
deriving (Int -> GrabOwnership -> ShowS
[GrabOwnership] -> ShowS
GrabOwnership -> String
(Int -> GrabOwnership -> ShowS)
-> (GrabOwnership -> String)
-> ([GrabOwnership] -> ShowS)
-> Show GrabOwnership
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GrabOwnership] -> ShowS
$cshowList :: [GrabOwnership] -> ShowS
show :: GrabOwnership -> String
$cshow :: GrabOwnership -> String
showsPrec :: Int -> GrabOwnership -> ShowS
$cshowsPrec :: Int -> GrabOwnership -> ShowS
Show, GrabOwnership -> GrabOwnership -> Bool
(GrabOwnership -> GrabOwnership -> Bool)
-> (GrabOwnership -> GrabOwnership -> Bool) -> Eq GrabOwnership
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GrabOwnership -> GrabOwnership -> Bool
$c/= :: GrabOwnership -> GrabOwnership -> Bool
== :: GrabOwnership -> GrabOwnership -> Bool
$c== :: GrabOwnership -> GrabOwnership -> Bool
Eq)
instance P.Enum GrabOwnership where
fromEnum :: GrabOwnership -> Int
fromEnum GrabOwnershipNone = 0
fromEnum GrabOwnershipWindow = 1
fromEnum GrabOwnershipApplication = 2
fromEnum (AnotherGrabOwnership k :: Int
k) = Int
k
toEnum :: Int -> GrabOwnership
toEnum 0 = GrabOwnership
GrabOwnershipNone
toEnum 1 = GrabOwnership
GrabOwnershipWindow
toEnum 2 = GrabOwnership
GrabOwnershipApplication
toEnum k :: Int
k = Int -> GrabOwnership
AnotherGrabOwnership Int
k
instance P.Ord GrabOwnership where
compare :: GrabOwnership -> GrabOwnership -> Ordering
compare a :: GrabOwnership
a b :: GrabOwnership
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (GrabOwnership -> Int
forall a. Enum a => a -> Int
P.fromEnum GrabOwnership
a) (GrabOwnership -> Int
forall a. Enum a => a -> Int
P.fromEnum GrabOwnership
b)
foreign import ccall "gdk_grab_ownership_get_type" c_gdk_grab_ownership_get_type ::
IO GType
instance BoxedEnum GrabOwnership where
boxedEnumType :: GrabOwnership -> IO GType
boxedEnumType _ = IO GType
c_gdk_grab_ownership_get_type
data GLError =
GLErrorNotAvailable
| GLErrorUnsupportedFormat
| GLErrorUnsupportedProfile
| AnotherGLError Int
deriving (Int -> GLError -> ShowS
[GLError] -> ShowS
GLError -> String
(Int -> GLError -> ShowS)
-> (GLError -> String) -> ([GLError] -> ShowS) -> Show GLError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GLError] -> ShowS
$cshowList :: [GLError] -> ShowS
show :: GLError -> String
$cshow :: GLError -> String
showsPrec :: Int -> GLError -> ShowS
$cshowsPrec :: Int -> GLError -> ShowS
Show, GLError -> GLError -> Bool
(GLError -> GLError -> Bool)
-> (GLError -> GLError -> Bool) -> Eq GLError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GLError -> GLError -> Bool
$c/= :: GLError -> GLError -> Bool
== :: GLError -> GLError -> Bool
$c== :: GLError -> GLError -> Bool
Eq)
instance P.Enum GLError where
fromEnum :: GLError -> Int
fromEnum GLErrorNotAvailable = 0
fromEnum GLErrorUnsupportedFormat = 1
fromEnum GLErrorUnsupportedProfile = 2
fromEnum (AnotherGLError k :: Int
k) = Int
k
toEnum :: Int -> GLError
toEnum 0 = GLError
GLErrorNotAvailable
toEnum 1 = GLError
GLErrorUnsupportedFormat
toEnum 2 = GLError
GLErrorUnsupportedProfile
toEnum k :: Int
k = Int -> GLError
AnotherGLError Int
k
instance P.Ord GLError where
compare :: GLError -> GLError -> Ordering
compare a :: GLError
a b :: GLError
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (GLError -> Int
forall a. Enum a => a -> Int
P.fromEnum GLError
a) (GLError -> Int
forall a. Enum a => a -> Int
P.fromEnum GLError
b)
instance GErrorClass GLError where
gerrorClassDomain :: GLError -> Text
gerrorClassDomain _ = "gdk-gl-error-quark"
catchGLError ::
IO a ->
(GLError -> GErrorMessage -> IO a) ->
IO a
catchGLError :: IO a -> (GLError -> Text -> IO a) -> IO a
catchGLError = IO a -> (GLError -> Text -> IO a) -> IO a
forall err a.
GErrorClass err =>
IO a -> (err -> Text -> IO a) -> IO a
catchGErrorJustDomain
handleGLError ::
(GLError -> GErrorMessage -> IO a) ->
IO a ->
IO a
handleGLError :: (GLError -> Text -> IO a) -> IO a -> IO a
handleGLError = (GLError -> Text -> IO a) -> IO a -> IO a
forall err a.
GErrorClass err =>
(err -> Text -> IO a) -> IO a -> IO a
handleGErrorJustDomain
foreign import ccall "gdk_gl_error_get_type" c_gdk_gl_error_get_type ::
IO GType
instance BoxedEnum GLError where
boxedEnumType :: GLError -> IO GType
boxedEnumType _ = IO GType
c_gdk_gl_error_get_type
data FullscreenMode =
FullscreenModeCurrentMonitor
| FullscreenModeAllMonitors
| AnotherFullscreenMode Int
deriving (Int -> FullscreenMode -> ShowS
[FullscreenMode] -> ShowS
FullscreenMode -> String
(Int -> FullscreenMode -> ShowS)
-> (FullscreenMode -> String)
-> ([FullscreenMode] -> ShowS)
-> Show FullscreenMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FullscreenMode] -> ShowS
$cshowList :: [FullscreenMode] -> ShowS
show :: FullscreenMode -> String
$cshow :: FullscreenMode -> String
showsPrec :: Int -> FullscreenMode -> ShowS
$cshowsPrec :: Int -> FullscreenMode -> ShowS
Show, FullscreenMode -> FullscreenMode -> Bool
(FullscreenMode -> FullscreenMode -> Bool)
-> (FullscreenMode -> FullscreenMode -> Bool) -> Eq FullscreenMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FullscreenMode -> FullscreenMode -> Bool
$c/= :: FullscreenMode -> FullscreenMode -> Bool
== :: FullscreenMode -> FullscreenMode -> Bool
$c== :: FullscreenMode -> FullscreenMode -> Bool
Eq)
instance P.Enum FullscreenMode where
fromEnum :: FullscreenMode -> Int
fromEnum FullscreenModeCurrentMonitor = 0
fromEnum FullscreenModeAllMonitors = 1
fromEnum (AnotherFullscreenMode k :: Int
k) = Int
k
toEnum :: Int -> FullscreenMode
toEnum 0 = FullscreenMode
FullscreenModeCurrentMonitor
toEnum 1 = FullscreenMode
FullscreenModeAllMonitors
toEnum k :: Int
k = Int -> FullscreenMode
AnotherFullscreenMode Int
k
instance P.Ord FullscreenMode where
compare :: FullscreenMode -> FullscreenMode -> Ordering
compare a :: FullscreenMode
a b :: FullscreenMode
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (FullscreenMode -> Int
forall a. Enum a => a -> Int
P.fromEnum FullscreenMode
a) (FullscreenMode -> Int
forall a. Enum a => a -> Int
P.fromEnum FullscreenMode
b)
foreign import ccall "gdk_fullscreen_mode_get_type" c_gdk_fullscreen_mode_get_type ::
IO GType
instance BoxedEnum FullscreenMode where
boxedEnumType :: FullscreenMode -> IO GType
boxedEnumType _ = IO GType
c_gdk_fullscreen_mode_get_type
data FilterReturn =
FilterReturnContinue
| FilterReturnTranslate
| FilterReturnRemove
| AnotherFilterReturn Int
deriving (Int -> FilterReturn -> ShowS
[FilterReturn] -> ShowS
FilterReturn -> String
(Int -> FilterReturn -> ShowS)
-> (FilterReturn -> String)
-> ([FilterReturn] -> ShowS)
-> Show FilterReturn
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FilterReturn] -> ShowS
$cshowList :: [FilterReturn] -> ShowS
show :: FilterReturn -> String
$cshow :: FilterReturn -> String
showsPrec :: Int -> FilterReturn -> ShowS
$cshowsPrec :: Int -> FilterReturn -> ShowS
Show, FilterReturn -> FilterReturn -> Bool
(FilterReturn -> FilterReturn -> Bool)
-> (FilterReturn -> FilterReturn -> Bool) -> Eq FilterReturn
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FilterReturn -> FilterReturn -> Bool
$c/= :: FilterReturn -> FilterReturn -> Bool
== :: FilterReturn -> FilterReturn -> Bool
$c== :: FilterReturn -> FilterReturn -> Bool
Eq)
instance P.Enum FilterReturn where
fromEnum :: FilterReturn -> Int
fromEnum FilterReturnContinue = 0
fromEnum FilterReturnTranslate = 1
fromEnum FilterReturnRemove = 2
fromEnum (AnotherFilterReturn k :: Int
k) = Int
k
toEnum :: Int -> FilterReturn
toEnum 0 = FilterReturn
FilterReturnContinue
toEnum 1 = FilterReturn
FilterReturnTranslate
toEnum 2 = FilterReturn
FilterReturnRemove
toEnum k :: Int
k = Int -> FilterReturn
AnotherFilterReturn Int
k
instance P.Ord FilterReturn where
compare :: FilterReturn -> FilterReturn -> Ordering
compare a :: FilterReturn
a b :: FilterReturn
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (FilterReturn -> Int
forall a. Enum a => a -> Int
P.fromEnum FilterReturn
a) (FilterReturn -> Int
forall a. Enum a => a -> Int
P.fromEnum FilterReturn
b)
foreign import ccall "gdk_filter_return_get_type" c_gdk_filter_return_get_type ::
IO GType
instance BoxedEnum FilterReturn where
boxedEnumType :: FilterReturn -> IO GType
boxedEnumType _ = IO GType
c_gdk_filter_return_get_type
data EventType =
EventTypeNothing
| EventTypeDelete
| EventTypeDestroy
| EventTypeExpose
| EventTypeMotionNotify
| EventTypeButtonPress
| EventType2buttonPress
| EventTypeDoubleButtonPress
| EventType3buttonPress
| EventTypeTripleButtonPress
| EventTypeButtonRelease
| EventTypeKeyPress
| EventTypeKeyRelease
| EventTypeEnterNotify
| EventTypeLeaveNotify
| EventTypeFocusChange
| EventTypeConfigure
| EventTypeMap
| EventTypeUnmap
| EventTypePropertyNotify
| EventTypeSelectionClear
| EventTypeSelectionRequest
| EventTypeSelectionNotify
| EventTypeProximityIn
| EventTypeProximityOut
| EventTypeDragEnter
| EventTypeDragLeave
| EventTypeDragMotion
| EventTypeDragStatus
| EventTypeDropStart
| EventTypeDropFinished
| EventTypeClientEvent
| EventTypeVisibilityNotify
| EventTypeScroll
| EventTypeWindowState
| EventTypeSetting
| EventTypeOwnerChange
| EventTypeGrabBroken
| EventTypeDamage
| EventTypeTouchBegin
| EventTypeTouchUpdate
| EventTypeTouchEnd
| EventTypeTouchCancel
| EventTypeTouchpadSwipe
| EventTypeTouchpadPinch
| EventTypePadButtonPress
| EventTypePadButtonRelease
| EventTypePadRing
| EventTypePadStrip
| EventTypePadGroupMode
| EventTypeEventLast
| AnotherEventType Int
deriving (Int -> EventType -> ShowS
[EventType] -> ShowS
EventType -> String
(Int -> EventType -> ShowS)
-> (EventType -> String)
-> ([EventType] -> ShowS)
-> Show EventType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [EventType] -> ShowS
$cshowList :: [EventType] -> ShowS
show :: EventType -> String
$cshow :: EventType -> String
showsPrec :: Int -> EventType -> ShowS
$cshowsPrec :: Int -> EventType -> ShowS
Show, EventType -> EventType -> Bool
(EventType -> EventType -> Bool)
-> (EventType -> EventType -> Bool) -> Eq EventType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: EventType -> EventType -> Bool
$c/= :: EventType -> EventType -> Bool
== :: EventType -> EventType -> Bool
$c== :: EventType -> EventType -> Bool
Eq)
instance P.Enum EventType where
fromEnum :: EventType -> Int
fromEnum EventTypeNothing = -1
fromEnum EventTypeDelete = 0
fromEnum EventTypeDestroy = 1
fromEnum EventTypeExpose = 2
fromEnum EventTypeMotionNotify = 3
fromEnum EventTypeButtonPress = 4
fromEnum EventType2buttonPress = 5
fromEnum EventTypeDoubleButtonPress = 5
fromEnum EventType3buttonPress = 6
fromEnum EventTypeTripleButtonPress = 6
fromEnum EventTypeButtonRelease = 7
fromEnum EventTypeKeyPress = 8
fromEnum EventTypeKeyRelease = 9
fromEnum EventTypeEnterNotify = 10
fromEnum EventTypeLeaveNotify = 11
fromEnum EventTypeFocusChange = 12
fromEnum EventTypeConfigure = 13
fromEnum EventTypeMap = 14
fromEnum EventTypeUnmap = 15
fromEnum EventTypePropertyNotify = 16
fromEnum EventTypeSelectionClear = 17
fromEnum EventTypeSelectionRequest = 18
fromEnum EventTypeSelectionNotify = 19
fromEnum EventTypeProximityIn = 20
fromEnum EventTypeProximityOut = 21
fromEnum EventTypeDragEnter = 22
fromEnum EventTypeDragLeave = 23
fromEnum EventTypeDragMotion = 24
fromEnum EventTypeDragStatus = 25
fromEnum EventTypeDropStart = 26
fromEnum EventTypeDropFinished = 27
fromEnum EventTypeClientEvent = 28
fromEnum EventTypeVisibilityNotify = 29
fromEnum EventTypeScroll = 31
fromEnum EventTypeWindowState = 32
fromEnum EventTypeSetting = 33
fromEnum EventTypeOwnerChange = 34
fromEnum EventTypeGrabBroken = 35
fromEnum EventTypeDamage = 36
fromEnum EventTypeTouchBegin = 37
fromEnum EventTypeTouchUpdate = 38
fromEnum EventTypeTouchEnd = 39
fromEnum EventTypeTouchCancel = 40
fromEnum EventTypeTouchpadSwipe = 41
fromEnum EventTypeTouchpadPinch = 42
fromEnum EventTypePadButtonPress = 43
fromEnum EventTypePadButtonRelease = 44
fromEnum EventTypePadRing = 45
fromEnum EventTypePadStrip = 46
fromEnum EventTypePadGroupMode = 47
fromEnum EventTypeEventLast = 48
fromEnum (AnotherEventType k :: Int
k) = Int
k
toEnum :: Int -> EventType
toEnum -1 = EventType
EventTypeNothing
toEnum 0 = EventType
EventTypeDelete
toEnum 1 = EventType
EventTypeDestroy
toEnum 2 = EventType
EventTypeExpose
toEnum 3 = EventType
EventTypeMotionNotify
toEnum 4 = EventType
EventTypeButtonPress
toEnum 5 = EventType
EventType2buttonPress
toEnum 6 = EventType
EventType3buttonPress
toEnum 7 = EventType
EventTypeButtonRelease
toEnum 8 = EventType
EventTypeKeyPress
toEnum 9 = EventType
EventTypeKeyRelease
toEnum 10 = EventType
EventTypeEnterNotify
toEnum 11 = EventType
EventTypeLeaveNotify
toEnum 12 = EventType
EventTypeFocusChange
toEnum 13 = EventType
EventTypeConfigure
toEnum 14 = EventType
EventTypeMap
toEnum 15 = EventType
EventTypeUnmap
toEnum 16 = EventType
EventTypePropertyNotify
toEnum 17 = EventType
EventTypeSelectionClear
toEnum 18 = EventType
EventTypeSelectionRequest
toEnum 19 = EventType
EventTypeSelectionNotify
toEnum 20 = EventType
EventTypeProximityIn
toEnum 21 = EventType
EventTypeProximityOut
toEnum 22 = EventType
EventTypeDragEnter
toEnum 23 = EventType
EventTypeDragLeave
toEnum 24 = EventType
EventTypeDragMotion
toEnum 25 = EventType
EventTypeDragStatus
toEnum 26 = EventType
EventTypeDropStart
toEnum 27 = EventType
EventTypeDropFinished
toEnum 28 = EventType
EventTypeClientEvent
toEnum 29 = EventType
EventTypeVisibilityNotify
toEnum 31 = EventType
EventTypeScroll
toEnum 32 = EventType
EventTypeWindowState
toEnum 33 = EventType
EventTypeSetting
toEnum 34 = EventType
EventTypeOwnerChange
toEnum 35 = EventType
EventTypeGrabBroken
toEnum 36 = EventType
EventTypeDamage
toEnum 37 = EventType
EventTypeTouchBegin
toEnum 38 = EventType
EventTypeTouchUpdate
toEnum 39 = EventType
EventTypeTouchEnd
toEnum 40 = EventType
EventTypeTouchCancel
toEnum 41 = EventType
EventTypeTouchpadSwipe
toEnum 42 = EventType
EventTypeTouchpadPinch
toEnum 43 = EventType
EventTypePadButtonPress
toEnum 44 = EventType
EventTypePadButtonRelease
toEnum 45 = EventType
EventTypePadRing
toEnum 46 = EventType
EventTypePadStrip
toEnum 47 = EventType
EventTypePadGroupMode
toEnum 48 = EventType
EventTypeEventLast
toEnum k :: Int
k = Int -> EventType
AnotherEventType Int
k
instance P.Ord EventType where
compare :: EventType -> EventType -> Ordering
compare a :: EventType
a b :: EventType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (EventType -> Int
forall a. Enum a => a -> Int
P.fromEnum EventType
a) (EventType -> Int
forall a. Enum a => a -> Int
P.fromEnum EventType
b)
foreign import ccall "gdk_event_type_get_type" c_gdk_event_type_get_type ::
IO GType
instance BoxedEnum EventType where
boxedEnumType :: EventType -> IO GType
boxedEnumType _ = IO GType
c_gdk_event_type_get_type
data DragProtocol =
DragProtocolNone
| DragProtocolMotif
| DragProtocolXdnd
| DragProtocolRootwin
| DragProtocolWin32Dropfiles
| DragProtocolOle2
| DragProtocolLocal
| DragProtocolWayland
| AnotherDragProtocol Int
deriving (Int -> DragProtocol -> ShowS
[DragProtocol] -> ShowS
DragProtocol -> String
(Int -> DragProtocol -> ShowS)
-> (DragProtocol -> String)
-> ([DragProtocol] -> ShowS)
-> Show DragProtocol
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DragProtocol] -> ShowS
$cshowList :: [DragProtocol] -> ShowS
show :: DragProtocol -> String
$cshow :: DragProtocol -> String
showsPrec :: Int -> DragProtocol -> ShowS
$cshowsPrec :: Int -> DragProtocol -> ShowS
Show, DragProtocol -> DragProtocol -> Bool
(DragProtocol -> DragProtocol -> Bool)
-> (DragProtocol -> DragProtocol -> Bool) -> Eq DragProtocol
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DragProtocol -> DragProtocol -> Bool
$c/= :: DragProtocol -> DragProtocol -> Bool
== :: DragProtocol -> DragProtocol -> Bool
$c== :: DragProtocol -> DragProtocol -> Bool
Eq)
instance P.Enum DragProtocol where
fromEnum :: DragProtocol -> Int
fromEnum DragProtocolNone = 0
fromEnum DragProtocolMotif = 1
fromEnum DragProtocolXdnd = 2
fromEnum DragProtocolRootwin = 3
fromEnum DragProtocolWin32Dropfiles = 4
fromEnum DragProtocolOle2 = 5
fromEnum DragProtocolLocal = 6
fromEnum DragProtocolWayland = 7
fromEnum (AnotherDragProtocol k :: Int
k) = Int
k
toEnum :: Int -> DragProtocol
toEnum 0 = DragProtocol
DragProtocolNone
toEnum 1 = DragProtocol
DragProtocolMotif
toEnum 2 = DragProtocol
DragProtocolXdnd
toEnum 3 = DragProtocol
DragProtocolRootwin
toEnum 4 = DragProtocol
DragProtocolWin32Dropfiles
toEnum 5 = DragProtocol
DragProtocolOle2
toEnum 6 = DragProtocol
DragProtocolLocal
toEnum 7 = DragProtocol
DragProtocolWayland
toEnum k :: Int
k = Int -> DragProtocol
AnotherDragProtocol Int
k
instance P.Ord DragProtocol where
compare :: DragProtocol -> DragProtocol -> Ordering
compare a :: DragProtocol
a b :: DragProtocol
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (DragProtocol -> Int
forall a. Enum a => a -> Int
P.fromEnum DragProtocol
a) (DragProtocol -> Int
forall a. Enum a => a -> Int
P.fromEnum DragProtocol
b)
foreign import ccall "gdk_drag_protocol_get_type" c_gdk_drag_protocol_get_type ::
IO GType
instance BoxedEnum DragProtocol where
boxedEnumType :: DragProtocol -> IO GType
boxedEnumType _ = IO GType
c_gdk_drag_protocol_get_type
data DragCancelReason =
DragCancelReasonNoTarget
| DragCancelReasonUserCancelled
| DragCancelReasonError
| AnotherDragCancelReason Int
deriving (Int -> DragCancelReason -> ShowS
[DragCancelReason] -> ShowS
DragCancelReason -> String
(Int -> DragCancelReason -> ShowS)
-> (DragCancelReason -> String)
-> ([DragCancelReason] -> ShowS)
-> Show DragCancelReason
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DragCancelReason] -> ShowS
$cshowList :: [DragCancelReason] -> ShowS
show :: DragCancelReason -> String
$cshow :: DragCancelReason -> String
showsPrec :: Int -> DragCancelReason -> ShowS
$cshowsPrec :: Int -> DragCancelReason -> ShowS
Show, DragCancelReason -> DragCancelReason -> Bool
(DragCancelReason -> DragCancelReason -> Bool)
-> (DragCancelReason -> DragCancelReason -> Bool)
-> Eq DragCancelReason
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DragCancelReason -> DragCancelReason -> Bool
$c/= :: DragCancelReason -> DragCancelReason -> Bool
== :: DragCancelReason -> DragCancelReason -> Bool
$c== :: DragCancelReason -> DragCancelReason -> Bool
Eq)
instance P.Enum DragCancelReason where
fromEnum :: DragCancelReason -> Int
fromEnum DragCancelReasonNoTarget = 0
fromEnum DragCancelReasonUserCancelled = 1
fromEnum DragCancelReasonError = 2
fromEnum (AnotherDragCancelReason k :: Int
k) = Int
k
toEnum :: Int -> DragCancelReason
toEnum 0 = DragCancelReason
DragCancelReasonNoTarget
toEnum 1 = DragCancelReason
DragCancelReasonUserCancelled
toEnum 2 = DragCancelReason
DragCancelReasonError
toEnum k :: Int
k = Int -> DragCancelReason
AnotherDragCancelReason Int
k
instance P.Ord DragCancelReason where
compare :: DragCancelReason -> DragCancelReason -> Ordering
compare a :: DragCancelReason
a b :: DragCancelReason
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (DragCancelReason -> Int
forall a. Enum a => a -> Int
P.fromEnum DragCancelReason
a) (DragCancelReason -> Int
forall a. Enum a => a -> Int
P.fromEnum DragCancelReason
b)
foreign import ccall "gdk_drag_cancel_reason_get_type" c_gdk_drag_cancel_reason_get_type ::
IO GType
instance BoxedEnum DragCancelReason where
boxedEnumType :: DragCancelReason -> IO GType
boxedEnumType _ = IO GType
c_gdk_drag_cancel_reason_get_type
data DeviceType =
DeviceTypeMaster
| DeviceTypeSlave
| DeviceTypeFloating
| AnotherDeviceType Int
deriving (Int -> DeviceType -> ShowS
[DeviceType] -> ShowS
DeviceType -> String
(Int -> DeviceType -> ShowS)
-> (DeviceType -> String)
-> ([DeviceType] -> ShowS)
-> Show DeviceType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DeviceType] -> ShowS
$cshowList :: [DeviceType] -> ShowS
show :: DeviceType -> String
$cshow :: DeviceType -> String
showsPrec :: Int -> DeviceType -> ShowS
$cshowsPrec :: Int -> DeviceType -> ShowS
Show, DeviceType -> DeviceType -> Bool
(DeviceType -> DeviceType -> Bool)
-> (DeviceType -> DeviceType -> Bool) -> Eq DeviceType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DeviceType -> DeviceType -> Bool
$c/= :: DeviceType -> DeviceType -> Bool
== :: DeviceType -> DeviceType -> Bool
$c== :: DeviceType -> DeviceType -> Bool
Eq)
instance P.Enum DeviceType where
fromEnum :: DeviceType -> Int
fromEnum DeviceTypeMaster = 0
fromEnum DeviceTypeSlave = 1
fromEnum DeviceTypeFloating = 2
fromEnum (AnotherDeviceType k :: Int
k) = Int
k
toEnum :: Int -> DeviceType
toEnum 0 = DeviceType
DeviceTypeMaster
toEnum 1 = DeviceType
DeviceTypeSlave
toEnum 2 = DeviceType
DeviceTypeFloating
toEnum k :: Int
k = Int -> DeviceType
AnotherDeviceType Int
k
instance P.Ord DeviceType where
compare :: DeviceType -> DeviceType -> Ordering
compare a :: DeviceType
a b :: DeviceType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (DeviceType -> Int
forall a. Enum a => a -> Int
P.fromEnum DeviceType
a) (DeviceType -> Int
forall a. Enum a => a -> Int
P.fromEnum DeviceType
b)
foreign import ccall "gdk_device_type_get_type" c_gdk_device_type_get_type ::
IO GType
instance BoxedEnum DeviceType where
boxedEnumType :: DeviceType -> IO GType
boxedEnumType _ = IO GType
c_gdk_device_type_get_type
data DeviceToolType =
DeviceToolTypeUnknown
| DeviceToolTypePen
| DeviceToolTypeEraser
| DeviceToolTypeBrush
| DeviceToolTypePencil
| DeviceToolTypeAirbrush
| DeviceToolTypeMouse
| DeviceToolTypeLens
| AnotherDeviceToolType Int
deriving (Int -> DeviceToolType -> ShowS
[DeviceToolType] -> ShowS
DeviceToolType -> String
(Int -> DeviceToolType -> ShowS)
-> (DeviceToolType -> String)
-> ([DeviceToolType] -> ShowS)
-> Show DeviceToolType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DeviceToolType] -> ShowS
$cshowList :: [DeviceToolType] -> ShowS
show :: DeviceToolType -> String
$cshow :: DeviceToolType -> String
showsPrec :: Int -> DeviceToolType -> ShowS
$cshowsPrec :: Int -> DeviceToolType -> ShowS
Show, DeviceToolType -> DeviceToolType -> Bool
(DeviceToolType -> DeviceToolType -> Bool)
-> (DeviceToolType -> DeviceToolType -> Bool) -> Eq DeviceToolType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DeviceToolType -> DeviceToolType -> Bool
$c/= :: DeviceToolType -> DeviceToolType -> Bool
== :: DeviceToolType -> DeviceToolType -> Bool
$c== :: DeviceToolType -> DeviceToolType -> Bool
Eq)
instance P.Enum DeviceToolType where
fromEnum :: DeviceToolType -> Int
fromEnum DeviceToolTypeUnknown = 0
fromEnum DeviceToolTypePen = 1
fromEnum DeviceToolTypeEraser = 2
fromEnum DeviceToolTypeBrush = 3
fromEnum DeviceToolTypePencil = 4
fromEnum DeviceToolTypeAirbrush = 5
fromEnum DeviceToolTypeMouse = 6
fromEnum DeviceToolTypeLens = 7
fromEnum (AnotherDeviceToolType k :: Int
k) = Int
k
toEnum :: Int -> DeviceToolType
toEnum 0 = DeviceToolType
DeviceToolTypeUnknown
toEnum 1 = DeviceToolType
DeviceToolTypePen
toEnum 2 = DeviceToolType
DeviceToolTypeEraser
toEnum 3 = DeviceToolType
DeviceToolTypeBrush
toEnum 4 = DeviceToolType
DeviceToolTypePencil
toEnum 5 = DeviceToolType
DeviceToolTypeAirbrush
toEnum 6 = DeviceToolType
DeviceToolTypeMouse
toEnum 7 = DeviceToolType
DeviceToolTypeLens
toEnum k :: Int
k = Int -> DeviceToolType
AnotherDeviceToolType Int
k
instance P.Ord DeviceToolType where
compare :: DeviceToolType -> DeviceToolType -> Ordering
compare a :: DeviceToolType
a b :: DeviceToolType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (DeviceToolType -> Int
forall a. Enum a => a -> Int
P.fromEnum DeviceToolType
a) (DeviceToolType -> Int
forall a. Enum a => a -> Int
P.fromEnum DeviceToolType
b)
foreign import ccall "gdk_device_tool_type_get_type" c_gdk_device_tool_type_get_type ::
IO GType
instance BoxedEnum DeviceToolType where
boxedEnumType :: DeviceToolType -> IO GType
boxedEnumType _ = IO GType
c_gdk_device_tool_type_get_type
data DevicePadFeature =
DevicePadFeatureButton
| DevicePadFeatureRing
| DevicePadFeatureStrip
| AnotherDevicePadFeature Int
deriving (Int -> DevicePadFeature -> ShowS
[DevicePadFeature] -> ShowS
DevicePadFeature -> String
(Int -> DevicePadFeature -> ShowS)
-> (DevicePadFeature -> String)
-> ([DevicePadFeature] -> ShowS)
-> Show DevicePadFeature
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DevicePadFeature] -> ShowS
$cshowList :: [DevicePadFeature] -> ShowS
show :: DevicePadFeature -> String
$cshow :: DevicePadFeature -> String
showsPrec :: Int -> DevicePadFeature -> ShowS
$cshowsPrec :: Int -> DevicePadFeature -> ShowS
Show, DevicePadFeature -> DevicePadFeature -> Bool
(DevicePadFeature -> DevicePadFeature -> Bool)
-> (DevicePadFeature -> DevicePadFeature -> Bool)
-> Eq DevicePadFeature
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DevicePadFeature -> DevicePadFeature -> Bool
$c/= :: DevicePadFeature -> DevicePadFeature -> Bool
== :: DevicePadFeature -> DevicePadFeature -> Bool
$c== :: DevicePadFeature -> DevicePadFeature -> Bool
Eq)
instance P.Enum DevicePadFeature where
fromEnum :: DevicePadFeature -> Int
fromEnum DevicePadFeatureButton = 0
fromEnum DevicePadFeatureRing = 1
fromEnum DevicePadFeatureStrip = 2
fromEnum (AnotherDevicePadFeature k :: Int
k) = Int
k
toEnum :: Int -> DevicePadFeature
toEnum 0 = DevicePadFeature
DevicePadFeatureButton
toEnum 1 = DevicePadFeature
DevicePadFeatureRing
toEnum 2 = DevicePadFeature
DevicePadFeatureStrip
toEnum k :: Int
k = Int -> DevicePadFeature
AnotherDevicePadFeature Int
k
instance P.Ord DevicePadFeature where
compare :: DevicePadFeature -> DevicePadFeature -> Ordering
compare a :: DevicePadFeature
a b :: DevicePadFeature
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (DevicePadFeature -> Int
forall a. Enum a => a -> Int
P.fromEnum DevicePadFeature
a) (DevicePadFeature -> Int
forall a. Enum a => a -> Int
P.fromEnum DevicePadFeature
b)
foreign import ccall "gdk_device_pad_feature_get_type" c_gdk_device_pad_feature_get_type ::
IO GType
instance BoxedEnum DevicePadFeature where
boxedEnumType :: DevicePadFeature -> IO GType
boxedEnumType _ = IO GType
c_gdk_device_pad_feature_get_type
data CursorType =
CursorTypeXCursor
| CursorTypeArrow
| CursorTypeBasedArrowDown
| CursorTypeBasedArrowUp
| CursorTypeBoat
| CursorTypeBogosity
| CursorTypeBottomLeftCorner
| CursorTypeBottomRightCorner
| CursorTypeBottomSide
| CursorTypeBottomTee
| CursorTypeBoxSpiral
| CursorTypeCenterPtr
| CursorTypeCircle
| CursorTypeClock
| CursorTypeCoffeeMug
| CursorTypeCross
| CursorTypeCrossReverse
| CursorTypeCrosshair
| CursorTypeDiamondCross
| CursorTypeDot
| CursorTypeDotbox
| CursorTypeDoubleArrow
| CursorTypeDraftLarge
| CursorTypeDraftSmall
| CursorTypeDrapedBox
| CursorTypeExchange
| CursorTypeFleur
| CursorTypeGobbler
| CursorTypeGumby
| CursorTypeHand1
| CursorTypeHand2
| CursorTypeHeart
| CursorTypeIcon
| CursorTypeIronCross
| CursorTypeLeftPtr
| CursorTypeLeftSide
| CursorTypeLeftTee
| CursorTypeLeftbutton
| CursorTypeLlAngle
| CursorTypeLrAngle
| CursorTypeMan
| CursorTypeMiddlebutton
| CursorTypeMouse
| CursorTypePencil
| CursorTypePirate
| CursorTypePlus
| CursorTypeQuestionArrow
| CursorTypeRightPtr
| CursorTypeRightSide
| CursorTypeRightTee
| CursorTypeRightbutton
| CursorTypeRtlLogo
| CursorTypeSailboat
| CursorTypeSbDownArrow
| CursorTypeSbHDoubleArrow
| CursorTypeSbLeftArrow
| CursorTypeSbRightArrow
| CursorTypeSbUpArrow
| CursorTypeSbVDoubleArrow
| CursorTypeShuttle
| CursorTypeSizing
| CursorTypeSpider
| CursorTypeSpraycan
| CursorTypeStar
| CursorTypeTarget
| CursorTypeTcross
| CursorTypeTopLeftArrow
| CursorTypeTopLeftCorner
| CursorTypeTopRightCorner
| CursorTypeTopSide
| CursorTypeTopTee
| CursorTypeTrek
| CursorTypeUlAngle
| CursorTypeUmbrella
| CursorTypeUrAngle
| CursorTypeWatch
| CursorTypeXterm
| CursorTypeLastCursor
| CursorTypeBlankCursor
| CursorTypeCursorIsPixmap
| AnotherCursorType Int
deriving (Int -> CursorType -> ShowS
[CursorType] -> ShowS
CursorType -> String
(Int -> CursorType -> ShowS)
-> (CursorType -> String)
-> ([CursorType] -> ShowS)
-> Show CursorType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CursorType] -> ShowS
$cshowList :: [CursorType] -> ShowS
show :: CursorType -> String
$cshow :: CursorType -> String
showsPrec :: Int -> CursorType -> ShowS
$cshowsPrec :: Int -> CursorType -> ShowS
Show, CursorType -> CursorType -> Bool
(CursorType -> CursorType -> Bool)
-> (CursorType -> CursorType -> Bool) -> Eq CursorType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CursorType -> CursorType -> Bool
$c/= :: CursorType -> CursorType -> Bool
== :: CursorType -> CursorType -> Bool
$c== :: CursorType -> CursorType -> Bool
Eq)
instance P.Enum CursorType where
fromEnum :: CursorType -> Int
fromEnum CursorTypeXCursor = 0
fromEnum CursorTypeArrow = 2
fromEnum CursorTypeBasedArrowDown = 4
fromEnum CursorTypeBasedArrowUp = 6
fromEnum CursorTypeBoat = 8
fromEnum CursorTypeBogosity = 10
fromEnum CursorTypeBottomLeftCorner = 12
fromEnum CursorTypeBottomRightCorner = 14
fromEnum CursorTypeBottomSide = 16
fromEnum CursorTypeBottomTee = 18
fromEnum CursorTypeBoxSpiral = 20
fromEnum CursorTypeCenterPtr = 22
fromEnum CursorTypeCircle = 24
fromEnum CursorTypeClock = 26
fromEnum CursorTypeCoffeeMug = 28
fromEnum CursorTypeCross = 30
fromEnum CursorTypeCrossReverse = 32
fromEnum CursorTypeCrosshair = 34
fromEnum CursorTypeDiamondCross = 36
fromEnum CursorTypeDot = 38
fromEnum CursorTypeDotbox = 40
fromEnum CursorTypeDoubleArrow = 42
fromEnum CursorTypeDraftLarge = 44
fromEnum CursorTypeDraftSmall = 46
fromEnum CursorTypeDrapedBox = 48
fromEnum CursorTypeExchange = 50
fromEnum CursorTypeFleur = 52
fromEnum CursorTypeGobbler = 54
fromEnum CursorTypeGumby = 56
fromEnum CursorTypeHand1 = 58
fromEnum CursorTypeHand2 = 60
fromEnum CursorTypeHeart = 62
fromEnum CursorTypeIcon = 64
fromEnum CursorTypeIronCross = 66
fromEnum CursorTypeLeftPtr = 68
fromEnum CursorTypeLeftSide = 70
fromEnum CursorTypeLeftTee = 72
fromEnum CursorTypeLeftbutton = 74
fromEnum CursorTypeLlAngle = 76
fromEnum CursorTypeLrAngle = 78
fromEnum CursorTypeMan = 80
fromEnum CursorTypeMiddlebutton = 82
fromEnum CursorTypeMouse = 84
fromEnum CursorTypePencil = 86
fromEnum CursorTypePirate = 88
fromEnum CursorTypePlus = 90
fromEnum CursorTypeQuestionArrow = 92
fromEnum CursorTypeRightPtr = 94
fromEnum CursorTypeRightSide = 96
fromEnum CursorTypeRightTee = 98
fromEnum CursorTypeRightbutton = 100
fromEnum CursorTypeRtlLogo = 102
fromEnum CursorTypeSailboat = 104
fromEnum CursorTypeSbDownArrow = 106
fromEnum CursorTypeSbHDoubleArrow = 108
fromEnum CursorTypeSbLeftArrow = 110
fromEnum CursorTypeSbRightArrow = 112
fromEnum CursorTypeSbUpArrow = 114
fromEnum CursorTypeSbVDoubleArrow = 116
fromEnum CursorTypeShuttle = 118
fromEnum CursorTypeSizing = 120
fromEnum CursorTypeSpider = 122
fromEnum CursorTypeSpraycan = 124
fromEnum CursorTypeStar = 126
fromEnum CursorTypeTarget = 128
fromEnum CursorTypeTcross = 130
fromEnum CursorTypeTopLeftArrow = 132
fromEnum CursorTypeTopLeftCorner = 134
fromEnum CursorTypeTopRightCorner = 136
fromEnum CursorTypeTopSide = 138
fromEnum CursorTypeTopTee = 140
fromEnum CursorTypeTrek = 142
fromEnum CursorTypeUlAngle = 144
fromEnum CursorTypeUmbrella = 146
fromEnum CursorTypeUrAngle = 148
fromEnum CursorTypeWatch = 150
fromEnum CursorTypeXterm = 152
fromEnum CursorTypeLastCursor = 153
fromEnum CursorTypeBlankCursor = -2
fromEnum CursorTypeCursorIsPixmap = -1
fromEnum (AnotherCursorType k :: Int
k) = Int
k
toEnum :: Int -> CursorType
toEnum 0 = CursorType
CursorTypeXCursor
toEnum 2 = CursorType
CursorTypeArrow
toEnum 4 = CursorType
CursorTypeBasedArrowDown
toEnum 6 = CursorType
CursorTypeBasedArrowUp
toEnum 8 = CursorType
CursorTypeBoat
toEnum 10 = CursorType
CursorTypeBogosity
toEnum 12 = CursorType
CursorTypeBottomLeftCorner
toEnum 14 = CursorType
CursorTypeBottomRightCorner
toEnum 16 = CursorType
CursorTypeBottomSide
toEnum 18 = CursorType
CursorTypeBottomTee
toEnum 20 = CursorType
CursorTypeBoxSpiral
toEnum 22 = CursorType
CursorTypeCenterPtr
toEnum 24 = CursorType
CursorTypeCircle
toEnum 26 = CursorType
CursorTypeClock
toEnum 28 = CursorType
CursorTypeCoffeeMug
toEnum 30 = CursorType
CursorTypeCross
toEnum 32 = CursorType
CursorTypeCrossReverse
toEnum 34 = CursorType
CursorTypeCrosshair
toEnum 36 = CursorType
CursorTypeDiamondCross
toEnum 38 = CursorType
CursorTypeDot
toEnum 40 = CursorType
CursorTypeDotbox
toEnum 42 = CursorType
CursorTypeDoubleArrow
toEnum 44 = CursorType
CursorTypeDraftLarge
toEnum 46 = CursorType
CursorTypeDraftSmall
toEnum 48 = CursorType
CursorTypeDrapedBox
toEnum 50 = CursorType
CursorTypeExchange
toEnum 52 = CursorType
CursorTypeFleur
toEnum 54 = CursorType
CursorTypeGobbler
toEnum 56 = CursorType
CursorTypeGumby
toEnum 58 = CursorType
CursorTypeHand1
toEnum 60 = CursorType
CursorTypeHand2
toEnum 62 = CursorType
CursorTypeHeart
toEnum 64 = CursorType
CursorTypeIcon
toEnum 66 = CursorType
CursorTypeIronCross
toEnum 68 = CursorType
CursorTypeLeftPtr
toEnum 70 = CursorType
CursorTypeLeftSide
toEnum 72 = CursorType
CursorTypeLeftTee
toEnum 74 = CursorType
CursorTypeLeftbutton
toEnum 76 = CursorType
CursorTypeLlAngle
toEnum 78 = CursorType
CursorTypeLrAngle
toEnum 80 = CursorType
CursorTypeMan
toEnum 82 = CursorType
CursorTypeMiddlebutton
toEnum 84 = CursorType
CursorTypeMouse
toEnum 86 = CursorType
CursorTypePencil
toEnum 88 = CursorType
CursorTypePirate
toEnum 90 = CursorType
CursorTypePlus
toEnum 92 = CursorType
CursorTypeQuestionArrow
toEnum 94 = CursorType
CursorTypeRightPtr
toEnum 96 = CursorType
CursorTypeRightSide
toEnum 98 = CursorType
CursorTypeRightTee
toEnum 100 = CursorType
CursorTypeRightbutton
toEnum 102 = CursorType
CursorTypeRtlLogo
toEnum 104 = CursorType
CursorTypeSailboat
toEnum 106 = CursorType
CursorTypeSbDownArrow
toEnum 108 = CursorType
CursorTypeSbHDoubleArrow
toEnum 110 = CursorType
CursorTypeSbLeftArrow
toEnum 112 = CursorType
CursorTypeSbRightArrow
toEnum 114 = CursorType
CursorTypeSbUpArrow
toEnum 116 = CursorType
CursorTypeSbVDoubleArrow
toEnum 118 = CursorType
CursorTypeShuttle
toEnum 120 = CursorType
CursorTypeSizing
toEnum 122 = CursorType
CursorTypeSpider
toEnum 124 = CursorType
CursorTypeSpraycan
toEnum 126 = CursorType
CursorTypeStar
toEnum 128 = CursorType
CursorTypeTarget
toEnum 130 = CursorType
CursorTypeTcross
toEnum 132 = CursorType
CursorTypeTopLeftArrow
toEnum 134 = CursorType
CursorTypeTopLeftCorner
toEnum 136 = CursorType
CursorTypeTopRightCorner
toEnum 138 = CursorType
CursorTypeTopSide
toEnum 140 = CursorType
CursorTypeTopTee
toEnum 142 = CursorType
CursorTypeTrek
toEnum 144 = CursorType
CursorTypeUlAngle
toEnum 146 = CursorType
CursorTypeUmbrella
toEnum 148 = CursorType
CursorTypeUrAngle
toEnum 150 = CursorType
CursorTypeWatch
toEnum 152 = CursorType
CursorTypeXterm
toEnum 153 = CursorType
CursorTypeLastCursor
toEnum -2 = CursorType
CursorTypeBlankCursor
toEnum -1 = CursorType
CursorTypeCursorIsPixmap
toEnum k :: Int
k = Int -> CursorType
AnotherCursorType Int
k
instance P.Ord CursorType where
compare :: CursorType -> CursorType -> Ordering
compare a :: CursorType
a b :: CursorType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (CursorType -> Int
forall a. Enum a => a -> Int
P.fromEnum CursorType
a) (CursorType -> Int
forall a. Enum a => a -> Int
P.fromEnum CursorType
b)
foreign import ccall "gdk_cursor_type_get_type" c_gdk_cursor_type_get_type ::
IO GType
instance BoxedEnum CursorType where
boxedEnumType :: CursorType -> IO GType
boxedEnumType _ = IO GType
c_gdk_cursor_type_get_type
data CrossingMode =
CrossingModeNormal
| CrossingModeGrab
| CrossingModeUngrab
| CrossingModeGtkGrab
| CrossingModeGtkUngrab
| CrossingModeStateChanged
| CrossingModeTouchBegin
| CrossingModeTouchEnd
| CrossingModeDeviceSwitch
| AnotherCrossingMode Int
deriving (Int -> CrossingMode -> ShowS
[CrossingMode] -> ShowS
CrossingMode -> String
(Int -> CrossingMode -> ShowS)
-> (CrossingMode -> String)
-> ([CrossingMode] -> ShowS)
-> Show CrossingMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CrossingMode] -> ShowS
$cshowList :: [CrossingMode] -> ShowS
show :: CrossingMode -> String
$cshow :: CrossingMode -> String
showsPrec :: Int -> CrossingMode -> ShowS
$cshowsPrec :: Int -> CrossingMode -> ShowS
Show, CrossingMode -> CrossingMode -> Bool
(CrossingMode -> CrossingMode -> Bool)
-> (CrossingMode -> CrossingMode -> Bool) -> Eq CrossingMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CrossingMode -> CrossingMode -> Bool
$c/= :: CrossingMode -> CrossingMode -> Bool
== :: CrossingMode -> CrossingMode -> Bool
$c== :: CrossingMode -> CrossingMode -> Bool
Eq)
instance P.Enum CrossingMode where
fromEnum :: CrossingMode -> Int
fromEnum CrossingModeNormal = 0
fromEnum CrossingModeGrab = 1
fromEnum CrossingModeUngrab = 2
fromEnum CrossingModeGtkGrab = 3
fromEnum CrossingModeGtkUngrab = 4
fromEnum CrossingModeStateChanged = 5
fromEnum CrossingModeTouchBegin = 6
fromEnum CrossingModeTouchEnd = 7
fromEnum CrossingModeDeviceSwitch = 8
fromEnum (AnotherCrossingMode k :: Int
k) = Int
k
toEnum :: Int -> CrossingMode
toEnum 0 = CrossingMode
CrossingModeNormal
toEnum 1 = CrossingMode
CrossingModeGrab
toEnum 2 = CrossingMode
CrossingModeUngrab
toEnum 3 = CrossingMode
CrossingModeGtkGrab
toEnum 4 = CrossingMode
CrossingModeGtkUngrab
toEnum 5 = CrossingMode
CrossingModeStateChanged
toEnum 6 = CrossingMode
CrossingModeTouchBegin
toEnum 7 = CrossingMode
CrossingModeTouchEnd
toEnum 8 = CrossingMode
CrossingModeDeviceSwitch
toEnum k :: Int
k = Int -> CrossingMode
AnotherCrossingMode Int
k
instance P.Ord CrossingMode where
compare :: CrossingMode -> CrossingMode -> Ordering
compare a :: CrossingMode
a b :: CrossingMode
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (CrossingMode -> Int
forall a. Enum a => a -> Int
P.fromEnum CrossingMode
a) (CrossingMode -> Int
forall a. Enum a => a -> Int
P.fromEnum CrossingMode
b)
foreign import ccall "gdk_crossing_mode_get_type" c_gdk_crossing_mode_get_type ::
IO GType
instance BoxedEnum CrossingMode where
boxedEnumType :: CrossingMode -> IO GType
boxedEnumType _ = IO GType
c_gdk_crossing_mode_get_type
data ByteOrder =
ByteOrderLsbFirst
| ByteOrderMsbFirst
| AnotherByteOrder Int
deriving (Int -> ByteOrder -> ShowS
[ByteOrder] -> ShowS
ByteOrder -> String
(Int -> ByteOrder -> ShowS)
-> (ByteOrder -> String)
-> ([ByteOrder] -> ShowS)
-> Show ByteOrder
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ByteOrder] -> ShowS
$cshowList :: [ByteOrder] -> ShowS
show :: ByteOrder -> String
$cshow :: ByteOrder -> String
showsPrec :: Int -> ByteOrder -> ShowS
$cshowsPrec :: Int -> ByteOrder -> ShowS
Show, ByteOrder -> ByteOrder -> Bool
(ByteOrder -> ByteOrder -> Bool)
-> (ByteOrder -> ByteOrder -> Bool) -> Eq ByteOrder
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ByteOrder -> ByteOrder -> Bool
$c/= :: ByteOrder -> ByteOrder -> Bool
== :: ByteOrder -> ByteOrder -> Bool
$c== :: ByteOrder -> ByteOrder -> Bool
Eq)
instance P.Enum ByteOrder where
fromEnum :: ByteOrder -> Int
fromEnum ByteOrderLsbFirst = 0
fromEnum ByteOrderMsbFirst = 1
fromEnum (AnotherByteOrder k :: Int
k) = Int
k
toEnum :: Int -> ByteOrder
toEnum 0 = ByteOrder
ByteOrderLsbFirst
toEnum 1 = ByteOrder
ByteOrderMsbFirst
toEnum k :: Int
k = Int -> ByteOrder
AnotherByteOrder Int
k
instance P.Ord ByteOrder where
compare :: ByteOrder -> ByteOrder -> Ordering
compare a :: ByteOrder
a b :: ByteOrder
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ByteOrder -> Int
forall a. Enum a => a -> Int
P.fromEnum ByteOrder
a) (ByteOrder -> Int
forall a. Enum a => a -> Int
P.fromEnum ByteOrder
b)
foreign import ccall "gdk_byte_order_get_type" c_gdk_byte_order_get_type ::
IO GType
instance BoxedEnum ByteOrder where
boxedEnumType :: ByteOrder -> IO GType
boxedEnumType _ = IO GType
c_gdk_byte_order_get_type
data AxisUse =
AxisUseIgnore
| AxisUseX
| AxisUseY
| AxisUsePressure
| AxisUseXtilt
| AxisUseYtilt
| AxisUseWheel
| AxisUseDistance
| AxisUseRotation
| AxisUseSlider
| AxisUseLast
| AnotherAxisUse Int
deriving (Int -> AxisUse -> ShowS
[AxisUse] -> ShowS
AxisUse -> String
(Int -> AxisUse -> ShowS)
-> (AxisUse -> String) -> ([AxisUse] -> ShowS) -> Show AxisUse
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AxisUse] -> ShowS
$cshowList :: [AxisUse] -> ShowS
show :: AxisUse -> String
$cshow :: AxisUse -> String
showsPrec :: Int -> AxisUse -> ShowS
$cshowsPrec :: Int -> AxisUse -> ShowS
Show, AxisUse -> AxisUse -> Bool
(AxisUse -> AxisUse -> Bool)
-> (AxisUse -> AxisUse -> Bool) -> Eq AxisUse
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AxisUse -> AxisUse -> Bool
$c/= :: AxisUse -> AxisUse -> Bool
== :: AxisUse -> AxisUse -> Bool
$c== :: AxisUse -> AxisUse -> Bool
Eq)
instance P.Enum AxisUse where
fromEnum :: AxisUse -> Int
fromEnum AxisUseIgnore = 0
fromEnum AxisUseX = 1
fromEnum AxisUseY = 2
fromEnum AxisUsePressure = 3
fromEnum AxisUseXtilt = 4
fromEnum AxisUseYtilt = 5
fromEnum AxisUseWheel = 6
fromEnum AxisUseDistance = 7
fromEnum AxisUseRotation = 8
fromEnum AxisUseSlider = 9
fromEnum AxisUseLast = 10
fromEnum (AnotherAxisUse k :: Int
k) = Int
k
toEnum :: Int -> AxisUse
toEnum 0 = AxisUse
AxisUseIgnore
toEnum 1 = AxisUse
AxisUseX
toEnum 2 = AxisUse
AxisUseY
toEnum 3 = AxisUse
AxisUsePressure
toEnum 4 = AxisUse
AxisUseXtilt
toEnum 5 = AxisUse
AxisUseYtilt
toEnum 6 = AxisUse
AxisUseWheel
toEnum 7 = AxisUse
AxisUseDistance
toEnum 8 = AxisUse
AxisUseRotation
toEnum 9 = AxisUse
AxisUseSlider
toEnum 10 = AxisUse
AxisUseLast
toEnum k :: Int
k = Int -> AxisUse
AnotherAxisUse Int
k
instance P.Ord AxisUse where
compare :: AxisUse -> AxisUse -> Ordering
compare a :: AxisUse
a b :: AxisUse
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (AxisUse -> Int
forall a. Enum a => a -> Int
P.fromEnum AxisUse
a) (AxisUse -> Int
forall a. Enum a => a -> Int
P.fromEnum AxisUse
b)
foreign import ccall "gdk_axis_use_get_type" c_gdk_axis_use_get_type ::
IO GType
instance BoxedEnum AxisUse where
boxedEnumType :: AxisUse -> IO GType
boxedEnumType _ = IO GType
c_gdk_axis_use_get_type