-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.Gdk.Enums
    ( 

 -- * Enumerations
-- ** AxisUse #enum:AxisUse#

    AxisUse(..)                             ,


-- ** ByteOrder #enum:ByteOrder#

    ByteOrder(..)                           ,


-- ** CrossingMode #enum:CrossingMode#

    CrossingMode(..)                        ,


-- ** CursorType #enum:CursorType#

    CursorType(..)                          ,


-- ** DevicePadFeature #enum:DevicePadFeature#

    DevicePadFeature(..)                    ,


-- ** DeviceToolType #enum:DeviceToolType#

    DeviceToolType(..)                      ,


-- ** DeviceType #enum:DeviceType#

    DeviceType(..)                          ,


-- ** DragCancelReason #enum:DragCancelReason#

    DragCancelReason(..)                    ,


-- ** DragProtocol #enum:DragProtocol#

    DragProtocol(..)                        ,


-- ** EventType #enum:EventType#

    EventType(..)                           ,


-- ** FilterReturn #enum:FilterReturn#

    FilterReturn(..)                        ,


-- ** FullscreenMode #enum:FullscreenMode#

    FullscreenMode(..)                      ,


-- ** GLError #enum:GLError#

    GLError(..)                             ,
    catchGLError                            ,
    handleGLError                           ,


-- ** GrabOwnership #enum:GrabOwnership#

    GrabOwnership(..)                       ,


-- ** GrabStatus #enum:GrabStatus#

    GrabStatus(..)                          ,


-- ** Gravity #enum:Gravity#

    Gravity(..)                             ,


-- ** InputMode #enum:InputMode#

    InputMode(..)                           ,


-- ** InputSource #enum:InputSource#

    InputSource(..)                         ,


-- ** ModifierIntent #enum:ModifierIntent#

    ModifierIntent(..)                      ,


-- ** NotifyType #enum:NotifyType#

    NotifyType(..)                          ,


-- ** OwnerChange #enum:OwnerChange#

    OwnerChange(..)                         ,


-- ** PropMode #enum:PropMode#

    PropMode(..)                            ,


-- ** PropertyState #enum:PropertyState#

    PropertyState(..)                       ,


-- ** ScrollDirection #enum:ScrollDirection#

    ScrollDirection(..)                     ,


-- ** SettingAction #enum:SettingAction#

    SettingAction(..)                       ,


-- ** Status #enum:Status#

    Status(..)                              ,


-- ** SubpixelLayout #enum:SubpixelLayout#

    SubpixelLayout(..)                      ,


-- ** TouchpadGesturePhase #enum:TouchpadGesturePhase#

    TouchpadGesturePhase(..)                ,


-- ** VisibilityState #enum:VisibilityState#

    VisibilityState(..)                     ,


-- ** VisualType #enum:VisualType#

    VisualType(..)                          ,


-- ** WindowEdge #enum:WindowEdge#

    WindowEdge(..)                          ,


-- ** WindowType #enum:WindowType#

    WindowType(..)                          ,


-- ** WindowTypeHint #enum:WindowTypeHint#

    WindowTypeHint(..)                      ,


-- ** WindowWindowClass #enum:WindowWindowClass#

    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.BasicTypes as B.Types
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 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


-- Enum WindowWindowClass
-- | /@gDKINPUTOUTPUT@/ windows are the standard kind of window you might expect.
-- Such windows receive events and are also displayed on screen.
-- /@gDKINPUTONLY@/ windows are invisible; they are usually placed above other
-- windows in order to trap or filter the events. You can’t draw on
-- /@gDKINPUTONLY@/ windows.
data WindowWindowClass = 
      WindowWindowClassInputOutput
    -- ^ window for graphics and events
    | WindowWindowClassInputOnly
    -- ^ window for events only
    | AnotherWindowWindowClass Int
    -- ^ Catch-all for unknown values
    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 WindowWindowClass
WindowWindowClassInputOutput = Int
0
    fromEnum WindowWindowClass
WindowWindowClassInputOnly = Int
1
    fromEnum (AnotherWindowWindowClass Int
k) = Int
k

    toEnum :: Int -> WindowWindowClass
toEnum Int
0 = WindowWindowClass
WindowWindowClassInputOutput
    toEnum Int
1 = WindowWindowClass
WindowWindowClassInputOnly
    toEnum Int
k = Int -> WindowWindowClass
AnotherWindowWindowClass Int
k

instance P.Ord WindowWindowClass where
    compare :: WindowWindowClass -> WindowWindowClass -> Ordering
compare WindowWindowClass
a 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)

type instance O.ParentTypes WindowWindowClass = '[]
instance O.HasParentTypes WindowWindowClass

foreign import ccall "gdk_window_window_class_get_type" c_gdk_window_window_class_get_type :: 
    IO GType

instance B.Types.TypedObject WindowWindowClass where
    glibType :: IO GType
glibType = IO GType
c_gdk_window_window_class_get_type

instance B.Types.BoxedEnum WindowWindowClass

-- Enum WindowTypeHint
-- | These are hints for the window manager that indicate what type of function
-- the window has. The window manager can use this when determining decoration
-- and behaviour of the window. The hint must be set before mapping the window.
-- 
-- See the <http://www.freedesktop.org/Standards/wm-spec Extended Window Manager Hints>
-- specification for more details about window types.
data WindowTypeHint = 
      WindowTypeHintNormal
    -- ^ Normal toplevel window.
    | WindowTypeHintDialog
    -- ^ Dialog window.
    | WindowTypeHintMenu
    -- ^ Window used to implement a menu; GTK+ uses
    --  this hint only for torn-off menus, see @/GtkTearoffMenuItem/@.
    | WindowTypeHintToolbar
    -- ^ Window used to implement toolbars.
    | WindowTypeHintSplashscreen
    -- ^ Window used to display a splash
    --  screen during application startup.
    | WindowTypeHintUtility
    -- ^ Utility windows which are not detached
    --  toolbars or dialogs.
    | WindowTypeHintDock
    -- ^ Used for creating dock or panel windows.
    | WindowTypeHintDesktop
    -- ^ Used for creating the desktop background
    --  window.
    | WindowTypeHintDropdownMenu
    -- ^ A menu that belongs to a menubar.
    | WindowTypeHintPopupMenu
    -- ^ A menu that does not belong to a menubar,
    --  e.g. a context menu.
    | WindowTypeHintTooltip
    -- ^ A tooltip.
    | WindowTypeHintNotification
    -- ^ A notification - typically a “bubble”
    --  that belongs to a status icon.
    | WindowTypeHintCombo
    -- ^ A popup from a combo box.
    | WindowTypeHintDnd
    -- ^ A window that is used to implement a DND cursor.
    | AnotherWindowTypeHint Int
    -- ^ Catch-all for unknown values
    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 WindowTypeHint
WindowTypeHintNormal = Int
0
    fromEnum WindowTypeHint
WindowTypeHintDialog = Int
1
    fromEnum WindowTypeHint
WindowTypeHintMenu = Int
2
    fromEnum WindowTypeHint
WindowTypeHintToolbar = Int
3
    fromEnum WindowTypeHint
WindowTypeHintSplashscreen = Int
4
    fromEnum WindowTypeHint
WindowTypeHintUtility = Int
5
    fromEnum WindowTypeHint
WindowTypeHintDock = Int
6
    fromEnum WindowTypeHint
WindowTypeHintDesktop = Int
7
    fromEnum WindowTypeHint
WindowTypeHintDropdownMenu = Int
8
    fromEnum WindowTypeHint
WindowTypeHintPopupMenu = Int
9
    fromEnum WindowTypeHint
WindowTypeHintTooltip = Int
10
    fromEnum WindowTypeHint
WindowTypeHintNotification = Int
11
    fromEnum WindowTypeHint
WindowTypeHintCombo = Int
12
    fromEnum WindowTypeHint
WindowTypeHintDnd = Int
13
    fromEnum (AnotherWindowTypeHint Int
k) = Int
k

    toEnum :: Int -> WindowTypeHint
toEnum Int
0 = WindowTypeHint
WindowTypeHintNormal
    toEnum Int
1 = WindowTypeHint
WindowTypeHintDialog
    toEnum Int
2 = WindowTypeHint
WindowTypeHintMenu
    toEnum Int
3 = WindowTypeHint
WindowTypeHintToolbar
    toEnum Int
4 = WindowTypeHint
WindowTypeHintSplashscreen
    toEnum Int
5 = WindowTypeHint
WindowTypeHintUtility
    toEnum Int
6 = WindowTypeHint
WindowTypeHintDock
    toEnum Int
7 = WindowTypeHint
WindowTypeHintDesktop
    toEnum Int
8 = WindowTypeHint
WindowTypeHintDropdownMenu
    toEnum Int
9 = WindowTypeHint
WindowTypeHintPopupMenu
    toEnum Int
10 = WindowTypeHint
WindowTypeHintTooltip
    toEnum Int
11 = WindowTypeHint
WindowTypeHintNotification
    toEnum Int
12 = WindowTypeHint
WindowTypeHintCombo
    toEnum Int
13 = WindowTypeHint
WindowTypeHintDnd
    toEnum Int
k = Int -> WindowTypeHint
AnotherWindowTypeHint Int
k

instance P.Ord WindowTypeHint where
    compare :: WindowTypeHint -> WindowTypeHint -> Ordering
compare WindowTypeHint
a 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)

type instance O.ParentTypes WindowTypeHint = '[]
instance O.HasParentTypes WindowTypeHint

foreign import ccall "gdk_window_type_hint_get_type" c_gdk_window_type_hint_get_type :: 
    IO GType

instance B.Types.TypedObject WindowTypeHint where
    glibType :: IO GType
glibType = IO GType
c_gdk_window_type_hint_get_type

instance B.Types.BoxedEnum WindowTypeHint

-- Enum WindowType
-- | Describes the kind of window.
data WindowType = 
      WindowTypeRoot
    -- ^ root window; this window has no parent, covers the entire
    --  screen, and is created by the window system
    | WindowTypeToplevel
    -- ^ toplevel window (used to implement @/GtkWindow/@)
    | WindowTypeChild
    -- ^ child window (used to implement e.g. @/GtkEntry/@)
    | WindowTypeTemp
    -- ^ override redirect temporary window (used to implement
    --  @/GtkMenu/@)
    | WindowTypeForeign
    -- ^ foreign window (see @/gdk_window_foreign_new()/@)
    | WindowTypeOffscreen
    -- ^ offscreen window (see
    --  [Offscreen Windows][OFFSCREEN-WINDOWS]). Since 2.18
    | WindowTypeSubsurface
    -- ^ subsurface-based window; This window is visually
    --  tied to a toplevel, and is moved\/stacked with it. Currently this window
    --  type is only implemented in Wayland. Since 3.14
    | AnotherWindowType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> WindowType -> ShowS
[WindowType] -> ShowS
WindowType -> String
(Int -> WindowType -> ShowS)
-> (WindowType -> String)
-> ([WindowType] -> ShowS)
-> Show WindowType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [WindowType] -> ShowS
$cshowList :: [WindowType] -> ShowS
show :: WindowType -> String
$cshow :: WindowType -> String
showsPrec :: Int -> WindowType -> ShowS
$cshowsPrec :: Int -> WindowType -> ShowS
Show, WindowType -> WindowType -> Bool
(WindowType -> WindowType -> Bool)
-> (WindowType -> WindowType -> Bool) -> Eq WindowType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: WindowType -> WindowType -> Bool
$c/= :: WindowType -> WindowType -> Bool
== :: WindowType -> WindowType -> Bool
$c== :: WindowType -> WindowType -> Bool
Eq)

instance P.Enum WindowType where
    fromEnum :: WindowType -> Int
fromEnum WindowType
WindowTypeRoot = Int
0
    fromEnum WindowType
WindowTypeToplevel = Int
1
    fromEnum WindowType
WindowTypeChild = Int
2
    fromEnum WindowType
WindowTypeTemp = Int
3
    fromEnum WindowType
WindowTypeForeign = Int
4
    fromEnum WindowType
WindowTypeOffscreen = Int
5
    fromEnum WindowType
WindowTypeSubsurface = Int
6
    fromEnum (AnotherWindowType Int
k) = Int
k

    toEnum :: Int -> WindowType
toEnum Int
0 = WindowType
WindowTypeRoot
    toEnum Int
1 = WindowType
WindowTypeToplevel
    toEnum Int
2 = WindowType
WindowTypeChild
    toEnum Int
3 = WindowType
WindowTypeTemp
    toEnum Int
4 = WindowType
WindowTypeForeign
    toEnum Int
5 = WindowType
WindowTypeOffscreen
    toEnum Int
6 = WindowType
WindowTypeSubsurface
    toEnum Int
k = Int -> WindowType
AnotherWindowType Int
k

instance P.Ord WindowType where
    compare :: WindowType -> WindowType -> Ordering
compare WindowType
a WindowType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (WindowType -> Int
forall a. Enum a => a -> Int
P.fromEnum WindowType
a) (WindowType -> Int
forall a. Enum a => a -> Int
P.fromEnum WindowType
b)

type instance O.ParentTypes WindowType = '[]
instance O.HasParentTypes WindowType

foreign import ccall "gdk_window_type_get_type" c_gdk_window_type_get_type :: 
    IO GType

instance B.Types.TypedObject WindowType where
    glibType :: IO GType
glibType = IO GType
c_gdk_window_type_get_type

instance B.Types.BoxedEnum WindowType

-- Enum WindowEdge
-- | Determines a window edge or corner.
data WindowEdge = 
      WindowEdgeNorthWest
    -- ^ the top left corner.
    | WindowEdgeNorth
    -- ^ the top edge.
    | WindowEdgeNorthEast
    -- ^ the top right corner.
    | WindowEdgeWest
    -- ^ the left edge.
    | WindowEdgeEast
    -- ^ the right edge.
    | WindowEdgeSouthWest
    -- ^ the lower left corner.
    | WindowEdgeSouth
    -- ^ the lower edge.
    | WindowEdgeSouthEast
    -- ^ the lower right corner.
    | AnotherWindowEdge Int
    -- ^ Catch-all for unknown values
    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 WindowEdge
WindowEdgeNorthWest = Int
0
    fromEnum WindowEdge
WindowEdgeNorth = Int
1
    fromEnum WindowEdge
WindowEdgeNorthEast = Int
2
    fromEnum WindowEdge
WindowEdgeWest = Int
3
    fromEnum WindowEdge
WindowEdgeEast = Int
4
    fromEnum WindowEdge
WindowEdgeSouthWest = Int
5
    fromEnum WindowEdge
WindowEdgeSouth = Int
6
    fromEnum WindowEdge
WindowEdgeSouthEast = Int
7
    fromEnum (AnotherWindowEdge Int
k) = Int
k

    toEnum :: Int -> WindowEdge
toEnum Int
0 = WindowEdge
WindowEdgeNorthWest
    toEnum Int
1 = WindowEdge
WindowEdgeNorth
    toEnum Int
2 = WindowEdge
WindowEdgeNorthEast
    toEnum Int
3 = WindowEdge
WindowEdgeWest
    toEnum Int
4 = WindowEdge
WindowEdgeEast
    toEnum Int
5 = WindowEdge
WindowEdgeSouthWest
    toEnum Int
6 = WindowEdge
WindowEdgeSouth
    toEnum Int
7 = WindowEdge
WindowEdgeSouthEast
    toEnum Int
k = Int -> WindowEdge
AnotherWindowEdge Int
k

instance P.Ord WindowEdge where
    compare :: WindowEdge -> WindowEdge -> Ordering
compare WindowEdge
a 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)

type instance O.ParentTypes WindowEdge = '[]
instance O.HasParentTypes WindowEdge

foreign import ccall "gdk_window_edge_get_type" c_gdk_window_edge_get_type :: 
    IO GType

instance B.Types.TypedObject WindowEdge where
    glibType :: IO GType
glibType = IO GType
c_gdk_window_edge_get_type

instance B.Types.BoxedEnum WindowEdge

-- Enum VisualType
-- | A set of values that describe the manner in which the pixel values
-- for a visual are converted into RGB values for display.
data VisualType = 
      VisualTypeStaticGray
    -- ^ Each pixel value indexes a grayscale value
    --     directly.
    | VisualTypeGrayscale
    -- ^ Each pixel is an index into a color map that
    --     maps pixel values into grayscale values. The color map can be
    --     changed by an application.
    | VisualTypeStaticColor
    -- ^ Each pixel value is an index into a predefined,
    --     unmodifiable color map that maps pixel values into RGB values.
    | VisualTypePseudoColor
    -- ^ Each pixel is an index into a color map that
    --     maps pixel values into rgb values. The color map can be changed by
    --     an application.
    | VisualTypeTrueColor
    -- ^ Each pixel value directly contains red, green,
    --     and blue components. Use 'GI.Gdk.Objects.Visual.visualGetRedPixelDetails', etc,
    --     to obtain information about how the components are assembled into
    --     a pixel value.
    | VisualTypeDirectColor
    -- ^ Each pixel value contains red, green, and blue
    --     components as for 'GI.Gdk.Enums.VisualTypeTrueColor', but the components are
    --     mapped via a color table into the final output table instead of
    --     being converted directly.
    | AnotherVisualType Int
    -- ^ Catch-all for unknown values
    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 VisualType
VisualTypeStaticGray = Int
0
    fromEnum VisualType
VisualTypeGrayscale = Int
1
    fromEnum VisualType
VisualTypeStaticColor = Int
2
    fromEnum VisualType
VisualTypePseudoColor = Int
3
    fromEnum VisualType
VisualTypeTrueColor = Int
4
    fromEnum VisualType
VisualTypeDirectColor = Int
5
    fromEnum (AnotherVisualType Int
k) = Int
k

    toEnum :: Int -> VisualType
toEnum Int
0 = VisualType
VisualTypeStaticGray
    toEnum Int
1 = VisualType
VisualTypeGrayscale
    toEnum Int
2 = VisualType
VisualTypeStaticColor
    toEnum Int
3 = VisualType
VisualTypePseudoColor
    toEnum Int
4 = VisualType
VisualTypeTrueColor
    toEnum Int
5 = VisualType
VisualTypeDirectColor
    toEnum Int
k = Int -> VisualType
AnotherVisualType Int
k

instance P.Ord VisualType where
    compare :: VisualType -> VisualType -> Ordering
compare VisualType
a 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)

type instance O.ParentTypes VisualType = '[]
instance O.HasParentTypes VisualType

foreign import ccall "gdk_visual_type_get_type" c_gdk_visual_type_get_type :: 
    IO GType

instance B.Types.TypedObject VisualType where
    glibType :: IO GType
glibType = IO GType
c_gdk_visual_type_get_type

instance B.Types.BoxedEnum VisualType

-- Enum VisibilityState
-- | Specifies the visiblity status of a window for a t'GI.Gdk.Structs.EventVisibility.EventVisibility'.
data VisibilityState = 
      VisibilityStateUnobscured
    -- ^ the window is completely visible.
    | VisibilityStatePartial
    -- ^ the window is partially visible.
    | VisibilityStateFullyObscured
    -- ^ the window is not visible at all.
    | AnotherVisibilityState Int
    -- ^ Catch-all for unknown values
    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 VisibilityState
VisibilityStateUnobscured = Int
0
    fromEnum VisibilityState
VisibilityStatePartial = Int
1
    fromEnum VisibilityState
VisibilityStateFullyObscured = Int
2
    fromEnum (AnotherVisibilityState Int
k) = Int
k

    toEnum :: Int -> VisibilityState
toEnum Int
0 = VisibilityState
VisibilityStateUnobscured
    toEnum Int
1 = VisibilityState
VisibilityStatePartial
    toEnum Int
2 = VisibilityState
VisibilityStateFullyObscured
    toEnum Int
k = Int -> VisibilityState
AnotherVisibilityState Int
k

instance P.Ord VisibilityState where
    compare :: VisibilityState -> VisibilityState -> Ordering
compare VisibilityState
a 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)

type instance O.ParentTypes VisibilityState = '[]
instance O.HasParentTypes VisibilityState

foreign import ccall "gdk_visibility_state_get_type" c_gdk_visibility_state_get_type :: 
    IO GType

instance B.Types.TypedObject VisibilityState where
    glibType :: IO GType
glibType = IO GType
c_gdk_visibility_state_get_type

instance B.Types.BoxedEnum VisibilityState

-- Enum TouchpadGesturePhase
-- | Specifies the current state of a touchpad gesture. All gestures are
-- guaranteed to begin with an event with phase 'GI.Gdk.Enums.TouchpadGesturePhaseBegin',
-- followed by 0 or several events with phase 'GI.Gdk.Enums.TouchpadGesturePhaseUpdate'.
-- 
-- A finished gesture may have 2 possible outcomes, an event with phase
-- 'GI.Gdk.Enums.TouchpadGesturePhaseEnd' will be emitted when the gesture is
-- considered successful, this should be used as the hint to perform any
-- permanent changes.
-- 
-- Cancelled gestures may be so for a variety of reasons, due to hardware
-- or the compositor, or due to the gesture recognition layers hinting the
-- gesture did not finish resolutely (eg. a 3rd finger being added during
-- a pinch gesture). In these cases, the last event will report the phase
-- 'GI.Gdk.Enums.TouchpadGesturePhaseCancel', this should be used as a hint
-- to undo any visible\/permanent changes that were done throughout the
-- progress of the gesture.
-- 
-- See also t'GI.Gdk.Structs.EventTouchpadSwipe.EventTouchpadSwipe' and t'GI.Gdk.Structs.EventTouchpadPinch.EventTouchpadPinch'.
data TouchpadGesturePhase = 
      TouchpadGesturePhaseBegin
    -- ^ The gesture has begun.
    | TouchpadGesturePhaseUpdate
    -- ^ The gesture has been updated.
    | TouchpadGesturePhaseEnd
    -- ^ The gesture was finished, changes
    --   should be permanently applied.
    | TouchpadGesturePhaseCancel
    -- ^ The gesture was cancelled, all
    --   changes should be undone.
    | AnotherTouchpadGesturePhase Int
    -- ^ Catch-all for unknown values
    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 TouchpadGesturePhase
TouchpadGesturePhaseBegin = Int
0
    fromEnum TouchpadGesturePhase
TouchpadGesturePhaseUpdate = Int
1
    fromEnum TouchpadGesturePhase
TouchpadGesturePhaseEnd = Int
2
    fromEnum TouchpadGesturePhase
TouchpadGesturePhaseCancel = Int
3
    fromEnum (AnotherTouchpadGesturePhase Int
k) = Int
k

    toEnum :: Int -> TouchpadGesturePhase
toEnum Int
0 = TouchpadGesturePhase
TouchpadGesturePhaseBegin
    toEnum Int
1 = TouchpadGesturePhase
TouchpadGesturePhaseUpdate
    toEnum Int
2 = TouchpadGesturePhase
TouchpadGesturePhaseEnd
    toEnum Int
3 = TouchpadGesturePhase
TouchpadGesturePhaseCancel
    toEnum Int
k = Int -> TouchpadGesturePhase
AnotherTouchpadGesturePhase Int
k

instance P.Ord TouchpadGesturePhase where
    compare :: TouchpadGesturePhase -> TouchpadGesturePhase -> Ordering
compare TouchpadGesturePhase
a 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)

type instance O.ParentTypes TouchpadGesturePhase = '[]
instance O.HasParentTypes TouchpadGesturePhase

foreign import ccall "gdk_touchpad_gesture_phase_get_type" c_gdk_touchpad_gesture_phase_get_type :: 
    IO GType

instance B.Types.TypedObject TouchpadGesturePhase where
    glibType :: IO GType
glibType = IO GType
c_gdk_touchpad_gesture_phase_get_type

instance B.Types.BoxedEnum TouchpadGesturePhase

-- Enum SubpixelLayout
-- | This enumeration describes how the red, green and blue components
-- of physical pixels on an output device are laid out.
-- 
-- /Since: 3.22/
data SubpixelLayout = 
      SubpixelLayoutUnknown
    -- ^ The layout is not known
    | SubpixelLayoutNone
    -- ^ Not organized in this way
    | SubpixelLayoutHorizontalRgb
    -- ^ The layout is horizontal, the order is RGB
    | SubpixelLayoutHorizontalBgr
    -- ^ The layout is horizontal, the order is BGR
    | SubpixelLayoutVerticalRgb
    -- ^ The layout is vertical, the order is RGB
    | SubpixelLayoutVerticalBgr
    -- ^ The layout is vertical, the order is BGR
    | AnotherSubpixelLayout Int
    -- ^ Catch-all for unknown values
    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 SubpixelLayout
SubpixelLayoutUnknown = Int
0
    fromEnum SubpixelLayout
SubpixelLayoutNone = Int
1
    fromEnum SubpixelLayout
SubpixelLayoutHorizontalRgb = Int
2
    fromEnum SubpixelLayout
SubpixelLayoutHorizontalBgr = Int
3
    fromEnum SubpixelLayout
SubpixelLayoutVerticalRgb = Int
4
    fromEnum SubpixelLayout
SubpixelLayoutVerticalBgr = Int
5
    fromEnum (AnotherSubpixelLayout Int
k) = Int
k

    toEnum :: Int -> SubpixelLayout
toEnum Int
0 = SubpixelLayout
SubpixelLayoutUnknown
    toEnum Int
1 = SubpixelLayout
SubpixelLayoutNone
    toEnum Int
2 = SubpixelLayout
SubpixelLayoutHorizontalRgb
    toEnum Int
3 = SubpixelLayout
SubpixelLayoutHorizontalBgr
    toEnum Int
4 = SubpixelLayout
SubpixelLayoutVerticalRgb
    toEnum Int
5 = SubpixelLayout
SubpixelLayoutVerticalBgr
    toEnum Int
k = Int -> SubpixelLayout
AnotherSubpixelLayout Int
k

instance P.Ord SubpixelLayout where
    compare :: SubpixelLayout -> SubpixelLayout -> Ordering
compare SubpixelLayout
a 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)

type instance O.ParentTypes SubpixelLayout = '[]
instance O.HasParentTypes SubpixelLayout

foreign import ccall "gdk_subpixel_layout_get_type" c_gdk_subpixel_layout_get_type :: 
    IO GType

instance B.Types.TypedObject SubpixelLayout where
    glibType :: IO GType
glibType = IO GType
c_gdk_subpixel_layout_get_type

instance B.Types.BoxedEnum SubpixelLayout

-- Enum Status
-- | /No description available in the introspection data./
data Status = 
      StatusOk
    -- ^ /No description available in the introspection data./
    | StatusError
    -- ^ /No description available in the introspection data./
    | StatusErrorParam
    -- ^ /No description available in the introspection data./
    | StatusErrorFile
    -- ^ /No description available in the introspection data./
    | StatusErrorMem
    -- ^ /No description available in the introspection data./
    | AnotherStatus Int
    -- ^ Catch-all for unknown values
    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 Status
StatusOk = Int
0
    fromEnum Status
StatusError = Int
-1
    fromEnum Status
StatusErrorParam = Int
-2
    fromEnum Status
StatusErrorFile = Int
-3
    fromEnum Status
StatusErrorMem = Int
-4
    fromEnum (AnotherStatus Int
k) = Int
k

    toEnum :: Int -> Status
toEnum Int
0 = Status
StatusOk
    toEnum Int
-1 = Status
StatusError
    toEnum Int
-2 = Status
StatusErrorParam
    toEnum Int
-3 = Status
StatusErrorFile
    toEnum Int
-4 = Status
StatusErrorMem
    toEnum Int
k = Int -> Status
AnotherStatus Int
k

instance P.Ord Status where
    compare :: Status -> Status -> Ordering
compare Status
a 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)

type instance O.ParentTypes Status = '[]
instance O.HasParentTypes Status

foreign import ccall "gdk_status_get_type" c_gdk_status_get_type :: 
    IO GType

instance B.Types.TypedObject Status where
    glibType :: IO GType
glibType = IO GType
c_gdk_status_get_type

instance B.Types.BoxedEnum Status

-- Enum SettingAction
-- | Specifies the kind of modification applied to a setting in a
-- t'GI.Gdk.Structs.EventSetting.EventSetting'.
data SettingAction = 
      SettingActionNew
    -- ^ a setting was added.
    | SettingActionChanged
    -- ^ a setting was changed.
    | SettingActionDeleted
    -- ^ a setting was deleted.
    | AnotherSettingAction Int
    -- ^ Catch-all for unknown values
    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 SettingAction
SettingActionNew = Int
0
    fromEnum SettingAction
SettingActionChanged = Int
1
    fromEnum SettingAction
SettingActionDeleted = Int
2
    fromEnum (AnotherSettingAction Int
k) = Int
k

    toEnum :: Int -> SettingAction
toEnum Int
0 = SettingAction
SettingActionNew
    toEnum Int
1 = SettingAction
SettingActionChanged
    toEnum Int
2 = SettingAction
SettingActionDeleted
    toEnum Int
k = Int -> SettingAction
AnotherSettingAction Int
k

instance P.Ord SettingAction where
    compare :: SettingAction -> SettingAction -> Ordering
compare SettingAction
a 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)

type instance O.ParentTypes SettingAction = '[]
instance O.HasParentTypes SettingAction

foreign import ccall "gdk_setting_action_get_type" c_gdk_setting_action_get_type :: 
    IO GType

instance B.Types.TypedObject SettingAction where
    glibType :: IO GType
glibType = IO GType
c_gdk_setting_action_get_type

instance B.Types.BoxedEnum SettingAction

-- Enum ScrollDirection
-- | Specifies the direction for t'GI.Gdk.Structs.EventScroll.EventScroll'.
data ScrollDirection = 
      ScrollDirectionUp
    -- ^ the window is scrolled up.
    | ScrollDirectionDown
    -- ^ the window is scrolled down.
    | ScrollDirectionLeft
    -- ^ the window is scrolled to the left.
    | ScrollDirectionRight
    -- ^ the window is scrolled to the right.
    | ScrollDirectionSmooth
    -- ^ the scrolling is determined by the delta values
    --   in t'GI.Gdk.Structs.EventScroll.EventScroll'. See 'GI.Gdk.Unions.Event.eventGetScrollDeltas'. Since: 3.4
    | AnotherScrollDirection Int
    -- ^ Catch-all for unknown values
    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 ScrollDirection
ScrollDirectionUp = Int
0
    fromEnum ScrollDirection
ScrollDirectionDown = Int
1
    fromEnum ScrollDirection
ScrollDirectionLeft = Int
2
    fromEnum ScrollDirection
ScrollDirectionRight = Int
3
    fromEnum ScrollDirection
ScrollDirectionSmooth = Int
4
    fromEnum (AnotherScrollDirection Int
k) = Int
k

    toEnum :: Int -> ScrollDirection
toEnum Int
0 = ScrollDirection
ScrollDirectionUp
    toEnum Int
1 = ScrollDirection
ScrollDirectionDown
    toEnum Int
2 = ScrollDirection
ScrollDirectionLeft
    toEnum Int
3 = ScrollDirection
ScrollDirectionRight
    toEnum Int
4 = ScrollDirection
ScrollDirectionSmooth
    toEnum Int
k = Int -> ScrollDirection
AnotherScrollDirection Int
k

instance P.Ord ScrollDirection where
    compare :: ScrollDirection -> ScrollDirection -> Ordering
compare ScrollDirection
a 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)

type instance O.ParentTypes ScrollDirection = '[]
instance O.HasParentTypes ScrollDirection

foreign import ccall "gdk_scroll_direction_get_type" c_gdk_scroll_direction_get_type :: 
    IO GType

instance B.Types.TypedObject ScrollDirection where
    glibType :: IO GType
glibType = IO GType
c_gdk_scroll_direction_get_type

instance B.Types.BoxedEnum ScrollDirection

-- Enum PropertyState
-- | Specifies the type of a property change for a t'GI.Gdk.Structs.EventProperty.EventProperty'.
data PropertyState = 
      PropertyStateNewValue
    -- ^ the property value was changed.
    | PropertyStateDelete
    -- ^ the property was deleted.
    | AnotherPropertyState Int
    -- ^ Catch-all for unknown values
    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 PropertyState
PropertyStateNewValue = Int
0
    fromEnum PropertyState
PropertyStateDelete = Int
1
    fromEnum (AnotherPropertyState Int
k) = Int
k

    toEnum :: Int -> PropertyState
toEnum Int
0 = PropertyState
PropertyStateNewValue
    toEnum Int
1 = PropertyState
PropertyStateDelete
    toEnum Int
k = Int -> PropertyState
AnotherPropertyState Int
k

instance P.Ord PropertyState where
    compare :: PropertyState -> PropertyState -> Ordering
compare PropertyState
a 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)

type instance O.ParentTypes PropertyState = '[]
instance O.HasParentTypes PropertyState

foreign import ccall "gdk_property_state_get_type" c_gdk_property_state_get_type :: 
    IO GType

instance B.Types.TypedObject PropertyState where
    glibType :: IO GType
glibType = IO GType
c_gdk_property_state_get_type

instance B.Types.BoxedEnum PropertyState

-- Enum PropMode
-- | Describes how existing data is combined with new data when
-- using @/gdk_property_change()/@.
data PropMode = 
      PropModeReplace
    -- ^ the new data replaces the existing data.
    | PropModePrepend
    -- ^ the new data is prepended to the existing data.
    | PropModeAppend
    -- ^ the new data is appended to the existing data.
    | AnotherPropMode Int
    -- ^ Catch-all for unknown values
    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 PropMode
PropModeReplace = Int
0
    fromEnum PropMode
PropModePrepend = Int
1
    fromEnum PropMode
PropModeAppend = Int
2
    fromEnum (AnotherPropMode Int
k) = Int
k

    toEnum :: Int -> PropMode
toEnum Int
0 = PropMode
PropModeReplace
    toEnum Int
1 = PropMode
PropModePrepend
    toEnum Int
2 = PropMode
PropModeAppend
    toEnum Int
k = Int -> PropMode
AnotherPropMode Int
k

instance P.Ord PropMode where
    compare :: PropMode -> PropMode -> Ordering
compare PropMode
a 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)

type instance O.ParentTypes PropMode = '[]
instance O.HasParentTypes PropMode

foreign import ccall "gdk_prop_mode_get_type" c_gdk_prop_mode_get_type :: 
    IO GType

instance B.Types.TypedObject PropMode where
    glibType :: IO GType
glibType = IO GType
c_gdk_prop_mode_get_type

instance B.Types.BoxedEnum PropMode

-- Enum OwnerChange
-- | Specifies why a selection ownership was changed.
data OwnerChange = 
      OwnerChangeNewOwner
    -- ^ some other app claimed the ownership
    | OwnerChangeDestroy
    -- ^ the window was destroyed
    | OwnerChangeClose
    -- ^ the client was closed
    | AnotherOwnerChange Int
    -- ^ Catch-all for unknown values
    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 OwnerChange
OwnerChangeNewOwner = Int
0
    fromEnum OwnerChange
OwnerChangeDestroy = Int
1
    fromEnum OwnerChange
OwnerChangeClose = Int
2
    fromEnum (AnotherOwnerChange Int
k) = Int
k

    toEnum :: Int -> OwnerChange
toEnum Int
0 = OwnerChange
OwnerChangeNewOwner
    toEnum Int
1 = OwnerChange
OwnerChangeDestroy
    toEnum Int
2 = OwnerChange
OwnerChangeClose
    toEnum Int
k = Int -> OwnerChange
AnotherOwnerChange Int
k

instance P.Ord OwnerChange where
    compare :: OwnerChange -> OwnerChange -> Ordering
compare OwnerChange
a 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)

type instance O.ParentTypes OwnerChange = '[]
instance O.HasParentTypes OwnerChange

foreign import ccall "gdk_owner_change_get_type" c_gdk_owner_change_get_type :: 
    IO GType

instance B.Types.TypedObject OwnerChange where
    glibType :: IO GType
glibType = IO GType
c_gdk_owner_change_get_type

instance B.Types.BoxedEnum OwnerChange

-- Enum NotifyType
-- | Specifies the kind of crossing for t'GI.Gdk.Structs.EventCrossing.EventCrossing'.
-- 
-- See the X11 protocol specification of LeaveNotify for
-- full details of crossing event generation.
data NotifyType = 
      NotifyTypeAncestor
    -- ^ the window is entered from an ancestor or
    --   left towards an ancestor.
    | NotifyTypeVirtual
    -- ^ the pointer moves between an ancestor and an
    --   inferior of the window.
    | NotifyTypeInferior
    -- ^ the window is entered from an inferior or
    --   left towards an inferior.
    | NotifyTypeNonlinear
    -- ^ the window is entered from or left towards
    --   a window which is neither an ancestor nor an inferior.
    | NotifyTypeNonlinearVirtual
    -- ^ the pointer moves between two windows
    --   which are not ancestors of each other and the window is part of
    --   the ancestor chain between one of these windows and their least
    --   common ancestor.
    | NotifyTypeUnknown
    -- ^ an unknown type of enter\/leave event occurred.
    | AnotherNotifyType Int
    -- ^ Catch-all for unknown values
    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 NotifyType
NotifyTypeAncestor = Int
0
    fromEnum NotifyType
NotifyTypeVirtual = Int
1
    fromEnum NotifyType
NotifyTypeInferior = Int
2
    fromEnum NotifyType
NotifyTypeNonlinear = Int
3
    fromEnum NotifyType
NotifyTypeNonlinearVirtual = Int
4
    fromEnum NotifyType
NotifyTypeUnknown = Int
5
    fromEnum (AnotherNotifyType Int
k) = Int
k

    toEnum :: Int -> NotifyType
toEnum Int
0 = NotifyType
NotifyTypeAncestor
    toEnum Int
1 = NotifyType
NotifyTypeVirtual
    toEnum Int
2 = NotifyType
NotifyTypeInferior
    toEnum Int
3 = NotifyType
NotifyTypeNonlinear
    toEnum Int
4 = NotifyType
NotifyTypeNonlinearVirtual
    toEnum Int
5 = NotifyType
NotifyTypeUnknown
    toEnum Int
k = Int -> NotifyType
AnotherNotifyType Int
k

instance P.Ord NotifyType where
    compare :: NotifyType -> NotifyType -> Ordering
compare NotifyType
a 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)

type instance O.ParentTypes NotifyType = '[]
instance O.HasParentTypes NotifyType

foreign import ccall "gdk_notify_type_get_type" c_gdk_notify_type_get_type :: 
    IO GType

instance B.Types.TypedObject NotifyType where
    glibType :: IO GType
glibType = IO GType
c_gdk_notify_type_get_type

instance B.Types.BoxedEnum NotifyType

-- Enum ModifierIntent
-- | This enum is used with 'GI.Gdk.Objects.Keymap.keymapGetModifierMask'
-- in order to determine what modifiers the
-- currently used windowing system backend uses for particular
-- purposes. For example, on X11\/Windows, the Control key is used for
-- invoking menu shortcuts (accelerators), whereas on Apple computers
-- it’s the Command key (which correspond to 'GI.Gdk.Flags.ModifierTypeControlMask' and
-- 'GI.Gdk.Flags.ModifierTypeMod2Mask', respectively).
-- 
-- /Since: 3.4/
data ModifierIntent = 
      ModifierIntentPrimaryAccelerator
    -- ^ the primary modifier used to invoke
    --  menu accelerators.
    | ModifierIntentContextMenu
    -- ^ the modifier used to invoke context menus.
    --  Note that mouse button 3 always triggers context menus. When this modifier
    --  is not 0, it additionally triggers context menus when used with mouse button 1.
    | ModifierIntentExtendSelection
    -- ^ the modifier used to extend selections
    --  using @modifier@-click or @modifier@-cursor-key
    | ModifierIntentModifySelection
    -- ^ the modifier used to modify selections,
    --  which in most cases means toggling the clicked item into or out of the selection.
    | ModifierIntentNoTextInput
    -- ^ when any of these modifiers is pressed, the
    --  key event cannot produce a symbol directly. This is meant to be used for
    --  input methods, and for use cases like typeahead search.
    | ModifierIntentShiftGroup
    -- ^ the modifier that switches between keyboard
    --  groups (AltGr on X11\/Windows and Option\/Alt on OS X).
    | ModifierIntentDefaultModMask
    -- ^ The set of modifier masks accepted
    -- as modifiers in accelerators. Needed because Command is mapped to MOD2 on
    -- OSX, which is widely used, but on X11 MOD2 is NumLock and using that for a
    -- mod key is problematic at best.
    -- Ref: https:\/\/bugzilla.gnome.org\/show_bug.cgi?id=736125.
    | AnotherModifierIntent Int
    -- ^ Catch-all for unknown values
    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 ModifierIntent
ModifierIntentPrimaryAccelerator = Int
0
    fromEnum ModifierIntent
ModifierIntentContextMenu = Int
1
    fromEnum ModifierIntent
ModifierIntentExtendSelection = Int
2
    fromEnum ModifierIntent
ModifierIntentModifySelection = Int
3
    fromEnum ModifierIntent
ModifierIntentNoTextInput = Int
4
    fromEnum ModifierIntent
ModifierIntentShiftGroup = Int
5
    fromEnum ModifierIntent
ModifierIntentDefaultModMask = Int
6
    fromEnum (AnotherModifierIntent Int
k) = Int
k

    toEnum :: Int -> ModifierIntent
toEnum Int
0 = ModifierIntent
ModifierIntentPrimaryAccelerator
    toEnum Int
1 = ModifierIntent
ModifierIntentContextMenu
    toEnum Int
2 = ModifierIntent
ModifierIntentExtendSelection
    toEnum Int
3 = ModifierIntent
ModifierIntentModifySelection
    toEnum Int
4 = ModifierIntent
ModifierIntentNoTextInput
    toEnum Int
5 = ModifierIntent
ModifierIntentShiftGroup
    toEnum Int
6 = ModifierIntent
ModifierIntentDefaultModMask
    toEnum Int
k = Int -> ModifierIntent
AnotherModifierIntent Int
k

instance P.Ord ModifierIntent where
    compare :: ModifierIntent -> ModifierIntent -> Ordering
compare ModifierIntent
a 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)

type instance O.ParentTypes ModifierIntent = '[]
instance O.HasParentTypes ModifierIntent

foreign import ccall "gdk_modifier_intent_get_type" c_gdk_modifier_intent_get_type :: 
    IO GType

instance B.Types.TypedObject ModifierIntent where
    glibType :: IO GType
glibType = IO GType
c_gdk_modifier_intent_get_type

instance B.Types.BoxedEnum ModifierIntent

-- Enum InputSource
-- | An enumeration describing the type of an input device in general terms.
data InputSource = 
      InputSourceMouse
    -- ^ the device is a mouse. (This will be reported for the core
    --                    pointer, even if it is something else, such as a trackball.)
    | InputSourcePen
    -- ^ the device is a stylus of a graphics tablet or similar device.
    | InputSourceEraser
    -- ^ the device is an eraser. Typically, this would be the other end
    --                     of a stylus on a graphics tablet.
    | InputSourceCursor
    -- ^ the device is a graphics tablet “puck” or similar device.
    | InputSourceKeyboard
    -- ^ the device is a keyboard.
    | InputSourceTouchscreen
    -- ^ the device is a direct-input touch device, such
    --     as a touchscreen or tablet. This device type has been added in 3.4.
    | InputSourceTouchpad
    -- ^ the device is an indirect touch device, such
    --     as a touchpad. This device type has been added in 3.4.
    | InputSourceTrackpoint
    -- ^ the device is a trackpoint. This device type has been
    --     added in 3.22
    | InputSourceTabletPad
    -- ^ the device is a \"pad\", a collection of buttons,
    --     rings and strips found in drawing tablets. This device type has been
    --     added in 3.22.
    | AnotherInputSource Int
    -- ^ Catch-all for unknown values
    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 InputSource
InputSourceMouse = Int
0
    fromEnum InputSource
InputSourcePen = Int
1
    fromEnum InputSource
InputSourceEraser = Int
2
    fromEnum InputSource
InputSourceCursor = Int
3
    fromEnum InputSource
InputSourceKeyboard = Int
4
    fromEnum InputSource
InputSourceTouchscreen = Int
5
    fromEnum InputSource
InputSourceTouchpad = Int
6
    fromEnum InputSource
InputSourceTrackpoint = Int
7
    fromEnum InputSource
InputSourceTabletPad = Int
8
    fromEnum (AnotherInputSource Int
k) = Int
k

    toEnum :: Int -> InputSource
toEnum Int
0 = InputSource
InputSourceMouse
    toEnum Int
1 = InputSource
InputSourcePen
    toEnum Int
2 = InputSource
InputSourceEraser
    toEnum Int
3 = InputSource
InputSourceCursor
    toEnum Int
4 = InputSource
InputSourceKeyboard
    toEnum Int
5 = InputSource
InputSourceTouchscreen
    toEnum Int
6 = InputSource
InputSourceTouchpad
    toEnum Int
7 = InputSource
InputSourceTrackpoint
    toEnum Int
8 = InputSource
InputSourceTabletPad
    toEnum Int
k = Int -> InputSource
AnotherInputSource Int
k

instance P.Ord InputSource where
    compare :: InputSource -> InputSource -> Ordering
compare InputSource
a 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)

type instance O.ParentTypes InputSource = '[]
instance O.HasParentTypes InputSource

foreign import ccall "gdk_input_source_get_type" c_gdk_input_source_get_type :: 
    IO GType

instance B.Types.TypedObject InputSource where
    glibType :: IO GType
glibType = IO GType
c_gdk_input_source_get_type

instance B.Types.BoxedEnum InputSource

-- Enum InputMode
-- | An enumeration that describes the mode of an input device.
data InputMode = 
      InputModeDisabled
    -- ^ the device is disabled and will not report any events.
    | InputModeScreen
    -- ^ the device is enabled. The device’s coordinate space
    --                   maps to the entire screen.
    | InputModeWindow
    -- ^ the device is enabled. The device’s coordinate space
    --                   is mapped to a single window. The manner in which this window
    --                   is chosen is undefined, but it will typically be the same
    --                   way in which the focus window for key events is determined.
    | AnotherInputMode Int
    -- ^ Catch-all for unknown values
    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 InputMode
InputModeDisabled = Int
0
    fromEnum InputMode
InputModeScreen = Int
1
    fromEnum InputMode
InputModeWindow = Int
2
    fromEnum (AnotherInputMode Int
k) = Int
k

    toEnum :: Int -> InputMode
toEnum Int
0 = InputMode
InputModeDisabled
    toEnum Int
1 = InputMode
InputModeScreen
    toEnum Int
2 = InputMode
InputModeWindow
    toEnum Int
k = Int -> InputMode
AnotherInputMode Int
k

instance P.Ord InputMode where
    compare :: InputMode -> InputMode -> Ordering
compare InputMode
a 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)

type instance O.ParentTypes InputMode = '[]
instance O.HasParentTypes InputMode

foreign import ccall "gdk_input_mode_get_type" c_gdk_input_mode_get_type :: 
    IO GType

instance B.Types.TypedObject InputMode where
    glibType :: IO GType
glibType = IO GType
c_gdk_input_mode_get_type

instance B.Types.BoxedEnum InputMode

-- Enum Gravity
-- | Defines the reference point of a window and the meaning of coordinates
-- passed to @/gtk_window_move()/@. See @/gtk_window_move()/@ and the \"implementation
-- notes\" section of the
-- <http://www.freedesktop.org/Standards/wm-spec Extended Window Manager Hints>
-- specification for more details.
data Gravity = 
      GravityNorthWest
    -- ^ the reference point is at the top left corner.
    | GravityNorth
    -- ^ the reference point is in the middle of the top edge.
    | GravityNorthEast
    -- ^ the reference point is at the top right corner.
    | GravityWest
    -- ^ the reference point is at the middle of the left edge.
    | GravityCenter
    -- ^ the reference point is at the center of the window.
    | GravityEast
    -- ^ the reference point is at the middle of the right edge.
    | GravitySouthWest
    -- ^ the reference point is at the lower left corner.
    | GravitySouth
    -- ^ the reference point is at the middle of the lower edge.
    | GravitySouthEast
    -- ^ the reference point is at the lower right corner.
    | GravityStatic
    -- ^ the reference point is at the top left corner of the
    --  window itself, ignoring window manager decorations.
    | AnotherGravity Int
    -- ^ Catch-all for unknown values
    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 Gravity
GravityNorthWest = Int
1
    fromEnum Gravity
GravityNorth = Int
2
    fromEnum Gravity
GravityNorthEast = Int
3
    fromEnum Gravity
GravityWest = Int
4
    fromEnum Gravity
GravityCenter = Int
5
    fromEnum Gravity
GravityEast = Int
6
    fromEnum Gravity
GravitySouthWest = Int
7
    fromEnum Gravity
GravitySouth = Int
8
    fromEnum Gravity
GravitySouthEast = Int
9
    fromEnum Gravity
GravityStatic = Int
10
    fromEnum (AnotherGravity Int
k) = Int
k

    toEnum :: Int -> Gravity
toEnum Int
1 = Gravity
GravityNorthWest
    toEnum Int
2 = Gravity
GravityNorth
    toEnum Int
3 = Gravity
GravityNorthEast
    toEnum Int
4 = Gravity
GravityWest
    toEnum Int
5 = Gravity
GravityCenter
    toEnum Int
6 = Gravity
GravityEast
    toEnum Int
7 = Gravity
GravitySouthWest
    toEnum Int
8 = Gravity
GravitySouth
    toEnum Int
9 = Gravity
GravitySouthEast
    toEnum Int
10 = Gravity
GravityStatic
    toEnum Int
k = Int -> Gravity
AnotherGravity Int
k

instance P.Ord Gravity where
    compare :: Gravity -> Gravity -> Ordering
compare Gravity
a 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)

type instance O.ParentTypes Gravity = '[]
instance O.HasParentTypes Gravity

foreign import ccall "gdk_gravity_get_type" c_gdk_gravity_get_type :: 
    IO GType

instance B.Types.TypedObject Gravity where
    glibType :: IO GType
glibType = IO GType
c_gdk_gravity_get_type

instance B.Types.BoxedEnum Gravity

-- Enum GrabStatus
-- | Returned by 'GI.Gdk.Objects.Device.deviceGrab', 'GI.Gdk.Functions.pointerGrab' and 'GI.Gdk.Functions.keyboardGrab' to
-- indicate success or the reason for the failure of the grab attempt.
data GrabStatus = 
      GrabStatusSuccess
    -- ^ the resource was successfully grabbed.
    | GrabStatusAlreadyGrabbed
    -- ^ the resource is actively grabbed by another client.
    | GrabStatusInvalidTime
    -- ^ the resource was grabbed more recently than the
    --  specified time.
    | GrabStatusNotViewable
    -- ^ the grab window or the /@confineTo@/ window are not
    --  viewable.
    | GrabStatusFrozen
    -- ^ the resource is frozen by an active grab of another client.
    | GrabStatusFailed
    -- ^ the grab failed for some other reason. Since 3.16
    | AnotherGrabStatus Int
    -- ^ Catch-all for unknown values
    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 GrabStatus
GrabStatusSuccess = Int
0
    fromEnum GrabStatus
GrabStatusAlreadyGrabbed = Int
1
    fromEnum GrabStatus
GrabStatusInvalidTime = Int
2
    fromEnum GrabStatus
GrabStatusNotViewable = Int
3
    fromEnum GrabStatus
GrabStatusFrozen = Int
4
    fromEnum GrabStatus
GrabStatusFailed = Int
5
    fromEnum (AnotherGrabStatus Int
k) = Int
k

    toEnum :: Int -> GrabStatus
toEnum Int
0 = GrabStatus
GrabStatusSuccess
    toEnum Int
1 = GrabStatus
GrabStatusAlreadyGrabbed
    toEnum Int
2 = GrabStatus
GrabStatusInvalidTime
    toEnum Int
3 = GrabStatus
GrabStatusNotViewable
    toEnum Int
4 = GrabStatus
GrabStatusFrozen
    toEnum Int
5 = GrabStatus
GrabStatusFailed
    toEnum Int
k = Int -> GrabStatus
AnotherGrabStatus Int
k

instance P.Ord GrabStatus where
    compare :: GrabStatus -> GrabStatus -> Ordering
compare GrabStatus
a 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)

type instance O.ParentTypes GrabStatus = '[]
instance O.HasParentTypes GrabStatus

foreign import ccall "gdk_grab_status_get_type" c_gdk_grab_status_get_type :: 
    IO GType

instance B.Types.TypedObject GrabStatus where
    glibType :: IO GType
glibType = IO GType
c_gdk_grab_status_get_type

instance B.Types.BoxedEnum GrabStatus

-- Enum GrabOwnership
-- | Defines how device grabs interact with other devices.
data GrabOwnership = 
      GrabOwnershipNone
    -- ^ All other devices’ events are allowed.
    | GrabOwnershipWindow
    -- ^ Other devices’ events are blocked for the grab window.
    | GrabOwnershipApplication
    -- ^ Other devices’ events are blocked for the whole application.
    | AnotherGrabOwnership Int
    -- ^ Catch-all for unknown values
    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 GrabOwnership
GrabOwnershipNone = Int
0
    fromEnum GrabOwnership
GrabOwnershipWindow = Int
1
    fromEnum GrabOwnership
GrabOwnershipApplication = Int
2
    fromEnum (AnotherGrabOwnership Int
k) = Int
k

    toEnum :: Int -> GrabOwnership
toEnum Int
0 = GrabOwnership
GrabOwnershipNone
    toEnum Int
1 = GrabOwnership
GrabOwnershipWindow
    toEnum Int
2 = GrabOwnership
GrabOwnershipApplication
    toEnum Int
k = Int -> GrabOwnership
AnotherGrabOwnership Int
k

instance P.Ord GrabOwnership where
    compare :: GrabOwnership -> GrabOwnership -> Ordering
compare GrabOwnership
a 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)

type instance O.ParentTypes GrabOwnership = '[]
instance O.HasParentTypes GrabOwnership

foreign import ccall "gdk_grab_ownership_get_type" c_gdk_grab_ownership_get_type :: 
    IO GType

instance B.Types.TypedObject GrabOwnership where
    glibType :: IO GType
glibType = IO GType
c_gdk_grab_ownership_get_type

instance B.Types.BoxedEnum GrabOwnership

-- Enum GLError
-- | Error enumeration for t'GI.Gdk.Objects.GLContext.GLContext'.
-- 
-- /Since: 3.16/
data GLError = 
      GLErrorNotAvailable
    -- ^ OpenGL support is not available
    | GLErrorUnsupportedFormat
    -- ^ The requested visual format is not supported
    | GLErrorUnsupportedProfile
    -- ^ The requested profile is not supported
    | AnotherGLError Int
    -- ^ Catch-all for unknown values
    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 GLError
GLErrorNotAvailable = Int
0
    fromEnum GLError
GLErrorUnsupportedFormat = Int
1
    fromEnum GLError
GLErrorUnsupportedProfile = Int
2
    fromEnum (AnotherGLError Int
k) = Int
k

    toEnum :: Int -> GLError
toEnum Int
0 = GLError
GLErrorNotAvailable
    toEnum Int
1 = GLError
GLErrorUnsupportedFormat
    toEnum Int
2 = GLError
GLErrorUnsupportedProfile
    toEnum Int
k = Int -> GLError
AnotherGLError Int
k

instance P.Ord GLError where
    compare :: GLError -> GLError -> Ordering
compare GLError
a 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 GLError
_ = Text
"gdk-gl-error-quark"

-- | Catch exceptions of type `GLError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
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

-- | Handle exceptions of type `GLError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
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

type instance O.ParentTypes GLError = '[]
instance O.HasParentTypes GLError

foreign import ccall "gdk_gl_error_get_type" c_gdk_gl_error_get_type :: 
    IO GType

instance B.Types.TypedObject GLError where
    glibType :: IO GType
glibType = IO GType
c_gdk_gl_error_get_type

instance B.Types.BoxedEnum GLError

-- Enum FullscreenMode
-- | Indicates which monitor (in a multi-head setup) a window should span over
-- when in fullscreen mode.
-- 
-- /Since: 3.8/
data FullscreenMode = 
      FullscreenModeCurrentMonitor
    -- ^ Fullscreen on current monitor only.
    | FullscreenModeAllMonitors
    -- ^ Span across all monitors when fullscreen.
    | AnotherFullscreenMode Int
    -- ^ Catch-all for unknown values
    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 FullscreenMode
FullscreenModeCurrentMonitor = Int
0
    fromEnum FullscreenMode
FullscreenModeAllMonitors = Int
1
    fromEnum (AnotherFullscreenMode Int
k) = Int
k

    toEnum :: Int -> FullscreenMode
toEnum Int
0 = FullscreenMode
FullscreenModeCurrentMonitor
    toEnum Int
1 = FullscreenMode
FullscreenModeAllMonitors
    toEnum Int
k = Int -> FullscreenMode
AnotherFullscreenMode Int
k

instance P.Ord FullscreenMode where
    compare :: FullscreenMode -> FullscreenMode -> Ordering
compare FullscreenMode
a 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)

type instance O.ParentTypes FullscreenMode = '[]
instance O.HasParentTypes FullscreenMode

foreign import ccall "gdk_fullscreen_mode_get_type" c_gdk_fullscreen_mode_get_type :: 
    IO GType

instance B.Types.TypedObject FullscreenMode where
    glibType :: IO GType
glibType = IO GType
c_gdk_fullscreen_mode_get_type

instance B.Types.BoxedEnum FullscreenMode

-- Enum FilterReturn
-- | Specifies the result of applying a t'GI.Gdk.Callbacks.FilterFunc' to a native event.
data FilterReturn = 
      FilterReturnContinue
    -- ^ event not handled, continue processing.
    | FilterReturnTranslate
    -- ^ native event translated into a GDK event and stored
    --  in the @event@ structure that was passed in.
    | FilterReturnRemove
    -- ^ event handled, terminate processing.
    | AnotherFilterReturn Int
    -- ^ Catch-all for unknown values
    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 FilterReturn
FilterReturnContinue = Int
0
    fromEnum FilterReturn
FilterReturnTranslate = Int
1
    fromEnum FilterReturn
FilterReturnRemove = Int
2
    fromEnum (AnotherFilterReturn Int
k) = Int
k

    toEnum :: Int -> FilterReturn
toEnum Int
0 = FilterReturn
FilterReturnContinue
    toEnum Int
1 = FilterReturn
FilterReturnTranslate
    toEnum Int
2 = FilterReturn
FilterReturnRemove
    toEnum Int
k = Int -> FilterReturn
AnotherFilterReturn Int
k

instance P.Ord FilterReturn where
    compare :: FilterReturn -> FilterReturn -> Ordering
compare FilterReturn
a 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)

type instance O.ParentTypes FilterReturn = '[]
instance O.HasParentTypes FilterReturn

foreign import ccall "gdk_filter_return_get_type" c_gdk_filter_return_get_type :: 
    IO GType

instance B.Types.TypedObject FilterReturn where
    glibType :: IO GType
glibType = IO GType
c_gdk_filter_return_get_type

instance B.Types.BoxedEnum FilterReturn

-- Enum EventType
-- | Specifies the type of the event.
-- 
-- Do not confuse these events with the signals that GTK+ widgets emit.
-- Although many of these events result in corresponding signals being emitted,
-- the events are often transformed or filtered along the way.
-- 
-- In some language bindings, the values 'GI.Gdk.Enums.EventType2buttonPress' and
-- 'GI.Gdk.Enums.EventType3buttonPress' would translate into something syntactically
-- invalid (eg @Gdk.EventType.2ButtonPress@, where a
-- symbol is not allowed to start with a number). In that case, the
-- aliases 'GI.Gdk.Enums.EventTypeDoubleButtonPress' and 'GI.Gdk.Enums.EventTypeTripleButtonPress' can
-- be used instead.
data EventType = 
      EventTypeNothing
    -- ^ a special code to indicate a null event.
    | EventTypeDelete
    -- ^ the window manager has requested that the toplevel window be
    --   hidden or destroyed, usually when the user clicks on a special icon in the
    --   title bar.
    | EventTypeDestroy
    -- ^ the window has been destroyed.
    | EventTypeExpose
    -- ^ all or part of the window has become visible and needs to be
    --   redrawn.
    | EventTypeMotionNotify
    -- ^ the pointer (usually a mouse) has moved.
    | EventTypeButtonPress
    -- ^ a mouse button has been pressed.
    | EventType2buttonPress
    -- ^ a mouse button has been double-clicked (clicked twice
    --   within a short period of time). Note that each click also generates a
    --   'GI.Gdk.Enums.EventTypeButtonPress' event.
    | EventTypeDoubleButtonPress
    -- ^ alias for 'GI.Gdk.Enums.EventType2buttonPress', added in 3.6.
    | EventType3buttonPress
    -- ^ a mouse button has been clicked 3 times in a short period
    --   of time. Note that each click also generates a 'GI.Gdk.Enums.EventTypeButtonPress' event.
    | EventTypeTripleButtonPress
    -- ^ alias for 'GI.Gdk.Enums.EventType3buttonPress', added in 3.6.
    | EventTypeButtonRelease
    -- ^ a mouse button has been released.
    | EventTypeKeyPress
    -- ^ a key has been pressed.
    | EventTypeKeyRelease
    -- ^ a key has been released.
    | EventTypeEnterNotify
    -- ^ the pointer has entered the window.
    | EventTypeLeaveNotify
    -- ^ the pointer has left the window.
    | EventTypeFocusChange
    -- ^ the keyboard focus has entered or left the window.
    | EventTypeConfigure
    -- ^ the size, position or stacking order of the window has changed.
    --   Note that GTK+ discards these events for 'GI.Gdk.Enums.WindowTypeChild' windows.
    | EventTypeMap
    -- ^ the window has been mapped.
    | EventTypeUnmap
    -- ^ the window has been unmapped.
    | EventTypePropertyNotify
    -- ^ a property on the window has been changed or deleted.
    | EventTypeSelectionClear
    -- ^ the application has lost ownership of a selection.
    | EventTypeSelectionRequest
    -- ^ another application has requested a selection.
    | EventTypeSelectionNotify
    -- ^ a selection has been received.
    | EventTypeProximityIn
    -- ^ an input device has moved into contact with a sensing
    --   surface (e.g. a touchscreen or graphics tablet).
    | EventTypeProximityOut
    -- ^ an input device has moved out of contact with a sensing
    --   surface.
    | EventTypeDragEnter
    -- ^ the mouse has entered the window while a drag is in progress.
    | EventTypeDragLeave
    -- ^ the mouse has left the window while a drag is in progress.
    | EventTypeDragMotion
    -- ^ the mouse has moved in the window while a drag is in
    --   progress.
    | EventTypeDragStatus
    -- ^ the status of the drag operation initiated by the window
    --   has changed.
    | EventTypeDropStart
    -- ^ a drop operation onto the window has started.
    | EventTypeDropFinished
    -- ^ the drop operation initiated by the window has completed.
    | EventTypeClientEvent
    -- ^ a message has been received from another application.
    | EventTypeVisibilityNotify
    -- ^ the window visibility status has changed.
    | EventTypeScroll
    -- ^ the scroll wheel was turned
    | EventTypeWindowState
    -- ^ the state of a window has changed. See t'GI.Gdk.Flags.WindowState'
    --   for the possible window states
    | EventTypeSetting
    -- ^ a setting has been modified.
    | EventTypeOwnerChange
    -- ^ the owner of a selection has changed. This event type
    --   was added in 2.6
    | EventTypeGrabBroken
    -- ^ a pointer or keyboard grab was broken. This event type
    --   was added in 2.8.
    | EventTypeDamage
    -- ^ the content of the window has been changed. This event type
    --   was added in 2.14.
    | EventTypeTouchBegin
    -- ^ A new touch event sequence has just started. This event
    --   type was added in 3.4.
    | EventTypeTouchUpdate
    -- ^ A touch event sequence has been updated. This event type
    --   was added in 3.4.
    | EventTypeTouchEnd
    -- ^ A touch event sequence has finished. This event type
    --   was added in 3.4.
    | EventTypeTouchCancel
    -- ^ A touch event sequence has been canceled. This event type
    --   was added in 3.4.
    | EventTypeTouchpadSwipe
    -- ^ A touchpad swipe gesture event, the current state
    --   is determined by its phase field. This event type was added in 3.18.
    | EventTypeTouchpadPinch
    -- ^ A touchpad pinch gesture event, the current state
    --   is determined by its phase field. This event type was added in 3.18.
    | EventTypePadButtonPress
    -- ^ A tablet pad button press event. This event type
    --   was added in 3.22.
    | EventTypePadButtonRelease
    -- ^ A tablet pad button release event. This event type
    --   was added in 3.22.
    | EventTypePadRing
    -- ^ A tablet pad axis event from a \"ring\". This event type was
    --   added in 3.22.
    | EventTypePadStrip
    -- ^ A tablet pad axis event from a \"strip\". This event type was
    --   added in 3.22.
    | EventTypePadGroupMode
    -- ^ A tablet pad group mode change. This event type was
    --   added in 3.22.
    | EventTypeEventLast
    -- ^ marks the end of the GdkEventType enumeration. Added in 2.18
    | AnotherEventType Int
    -- ^ Catch-all for unknown values
    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 EventType
EventTypeNothing = Int
-1
    fromEnum EventType
EventTypeDelete = Int
0
    fromEnum EventType
EventTypeDestroy = Int
1
    fromEnum EventType
EventTypeExpose = Int
2
    fromEnum EventType
EventTypeMotionNotify = Int
3
    fromEnum EventType
EventTypeButtonPress = Int
4
    fromEnum EventType
EventType2buttonPress = Int
5
    fromEnum EventType
EventTypeDoubleButtonPress = Int
5
    fromEnum EventType
EventType3buttonPress = Int
6
    fromEnum EventType
EventTypeTripleButtonPress = Int
6
    fromEnum EventType
EventTypeButtonRelease = Int
7
    fromEnum EventType
EventTypeKeyPress = Int
8
    fromEnum EventType
EventTypeKeyRelease = Int
9
    fromEnum EventType
EventTypeEnterNotify = Int
10
    fromEnum EventType
EventTypeLeaveNotify = Int
11
    fromEnum EventType
EventTypeFocusChange = Int
12
    fromEnum EventType
EventTypeConfigure = Int
13
    fromEnum EventType
EventTypeMap = Int
14
    fromEnum EventType
EventTypeUnmap = Int
15
    fromEnum EventType
EventTypePropertyNotify = Int
16
    fromEnum EventType
EventTypeSelectionClear = Int
17
    fromEnum EventType
EventTypeSelectionRequest = Int
18
    fromEnum EventType
EventTypeSelectionNotify = Int
19
    fromEnum EventType
EventTypeProximityIn = Int
20
    fromEnum EventType
EventTypeProximityOut = Int
21
    fromEnum EventType
EventTypeDragEnter = Int
22
    fromEnum EventType
EventTypeDragLeave = Int
23
    fromEnum EventType
EventTypeDragMotion = Int
24
    fromEnum EventType
EventTypeDragStatus = Int
25
    fromEnum EventType
EventTypeDropStart = Int
26
    fromEnum EventType
EventTypeDropFinished = Int
27
    fromEnum EventType
EventTypeClientEvent = Int
28
    fromEnum EventType
EventTypeVisibilityNotify = Int
29
    fromEnum EventType
EventTypeScroll = Int
31
    fromEnum EventType
EventTypeWindowState = Int
32
    fromEnum EventType
EventTypeSetting = Int
33
    fromEnum EventType
EventTypeOwnerChange = Int
34
    fromEnum EventType
EventTypeGrabBroken = Int
35
    fromEnum EventType
EventTypeDamage = Int
36
    fromEnum EventType
EventTypeTouchBegin = Int
37
    fromEnum EventType
EventTypeTouchUpdate = Int
38
    fromEnum EventType
EventTypeTouchEnd = Int
39
    fromEnum EventType
EventTypeTouchCancel = Int
40
    fromEnum EventType
EventTypeTouchpadSwipe = Int
41
    fromEnum EventType
EventTypeTouchpadPinch = Int
42
    fromEnum EventType
EventTypePadButtonPress = Int
43
    fromEnum EventType
EventTypePadButtonRelease = Int
44
    fromEnum EventType
EventTypePadRing = Int
45
    fromEnum EventType
EventTypePadStrip = Int
46
    fromEnum EventType
EventTypePadGroupMode = Int
47
    fromEnum EventType
EventTypeEventLast = Int
48
    fromEnum (AnotherEventType Int
k) = Int
k

    toEnum :: Int -> EventType
toEnum Int
-1 = EventType
EventTypeNothing
    toEnum Int
0 = EventType
EventTypeDelete
    toEnum Int
1 = EventType
EventTypeDestroy
    toEnum Int
2 = EventType
EventTypeExpose
    toEnum Int
3 = EventType
EventTypeMotionNotify
    toEnum Int
4 = EventType
EventTypeButtonPress
    toEnum Int
5 = EventType
EventType2buttonPress
    toEnum Int
6 = EventType
EventType3buttonPress
    toEnum Int
7 = EventType
EventTypeButtonRelease
    toEnum Int
8 = EventType
EventTypeKeyPress
    toEnum Int
9 = EventType
EventTypeKeyRelease
    toEnum Int
10 = EventType
EventTypeEnterNotify
    toEnum Int
11 = EventType
EventTypeLeaveNotify
    toEnum Int
12 = EventType
EventTypeFocusChange
    toEnum Int
13 = EventType
EventTypeConfigure
    toEnum Int
14 = EventType
EventTypeMap
    toEnum Int
15 = EventType
EventTypeUnmap
    toEnum Int
16 = EventType
EventTypePropertyNotify
    toEnum Int
17 = EventType
EventTypeSelectionClear
    toEnum Int
18 = EventType
EventTypeSelectionRequest
    toEnum Int
19 = EventType
EventTypeSelectionNotify
    toEnum Int
20 = EventType
EventTypeProximityIn
    toEnum Int
21 = EventType
EventTypeProximityOut
    toEnum Int
22 = EventType
EventTypeDragEnter
    toEnum Int
23 = EventType
EventTypeDragLeave
    toEnum Int
24 = EventType
EventTypeDragMotion
    toEnum Int
25 = EventType
EventTypeDragStatus
    toEnum Int
26 = EventType
EventTypeDropStart
    toEnum Int
27 = EventType
EventTypeDropFinished
    toEnum Int
28 = EventType
EventTypeClientEvent
    toEnum Int
29 = EventType
EventTypeVisibilityNotify
    toEnum Int
31 = EventType
EventTypeScroll
    toEnum Int
32 = EventType
EventTypeWindowState
    toEnum Int
33 = EventType
EventTypeSetting
    toEnum Int
34 = EventType
EventTypeOwnerChange
    toEnum Int
35 = EventType
EventTypeGrabBroken
    toEnum Int
36 = EventType
EventTypeDamage
    toEnum Int
37 = EventType
EventTypeTouchBegin
    toEnum Int
38 = EventType
EventTypeTouchUpdate
    toEnum Int
39 = EventType
EventTypeTouchEnd
    toEnum Int
40 = EventType
EventTypeTouchCancel
    toEnum Int
41 = EventType
EventTypeTouchpadSwipe
    toEnum Int
42 = EventType
EventTypeTouchpadPinch
    toEnum Int
43 = EventType
EventTypePadButtonPress
    toEnum Int
44 = EventType
EventTypePadButtonRelease
    toEnum Int
45 = EventType
EventTypePadRing
    toEnum Int
46 = EventType
EventTypePadStrip
    toEnum Int
47 = EventType
EventTypePadGroupMode
    toEnum Int
48 = EventType
EventTypeEventLast
    toEnum Int
k = Int -> EventType
AnotherEventType Int
k

instance P.Ord EventType where
    compare :: EventType -> EventType -> Ordering
compare EventType
a 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)

type instance O.ParentTypes EventType = '[]
instance O.HasParentTypes EventType

foreign import ccall "gdk_event_type_get_type" c_gdk_event_type_get_type :: 
    IO GType

instance B.Types.TypedObject EventType where
    glibType :: IO GType
glibType = IO GType
c_gdk_event_type_get_type

instance B.Types.BoxedEnum EventType

-- Enum DragProtocol
-- | Used in t'GI.Gdk.Objects.DragContext.DragContext' to indicate the protocol according to
-- which DND is done.
data DragProtocol = 
      DragProtocolNone
    -- ^ no protocol.
    | DragProtocolMotif
    -- ^ The Motif DND protocol. No longer supported
    | DragProtocolXdnd
    -- ^ The Xdnd protocol.
    | DragProtocolRootwin
    -- ^ An extension to the Xdnd protocol for
    --  unclaimed root window drops.
    | DragProtocolWin32Dropfiles
    -- ^ The simple WM_DROPFILES protocol.
    | DragProtocolOle2
    -- ^ The complex OLE2 DND protocol (not implemented).
    | DragProtocolLocal
    -- ^ Intra-application DND.
    | DragProtocolWayland
    -- ^ Wayland DND protocol.
    | AnotherDragProtocol Int
    -- ^ Catch-all for unknown values
    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 DragProtocol
DragProtocolNone = Int
0
    fromEnum DragProtocol
DragProtocolMotif = Int
1
    fromEnum DragProtocol
DragProtocolXdnd = Int
2
    fromEnum DragProtocol
DragProtocolRootwin = Int
3
    fromEnum DragProtocol
DragProtocolWin32Dropfiles = Int
4
    fromEnum DragProtocol
DragProtocolOle2 = Int
5
    fromEnum DragProtocol
DragProtocolLocal = Int
6
    fromEnum DragProtocol
DragProtocolWayland = Int
7
    fromEnum (AnotherDragProtocol Int
k) = Int
k

    toEnum :: Int -> DragProtocol
toEnum Int
0 = DragProtocol
DragProtocolNone
    toEnum Int
1 = DragProtocol
DragProtocolMotif
    toEnum Int
2 = DragProtocol
DragProtocolXdnd
    toEnum Int
3 = DragProtocol
DragProtocolRootwin
    toEnum Int
4 = DragProtocol
DragProtocolWin32Dropfiles
    toEnum Int
5 = DragProtocol
DragProtocolOle2
    toEnum Int
6 = DragProtocol
DragProtocolLocal
    toEnum Int
7 = DragProtocol
DragProtocolWayland
    toEnum Int
k = Int -> DragProtocol
AnotherDragProtocol Int
k

instance P.Ord DragProtocol where
    compare :: DragProtocol -> DragProtocol -> Ordering
compare DragProtocol
a 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)

type instance O.ParentTypes DragProtocol = '[]
instance O.HasParentTypes DragProtocol

foreign import ccall "gdk_drag_protocol_get_type" c_gdk_drag_protocol_get_type :: 
    IO GType

instance B.Types.TypedObject DragProtocol where
    glibType :: IO GType
glibType = IO GType
c_gdk_drag_protocol_get_type

instance B.Types.BoxedEnum DragProtocol

-- Enum DragCancelReason
-- | Used in t'GI.Gdk.Objects.DragContext.DragContext' to the reason of a cancelled DND operation.
-- 
-- /Since: 3.20/
data DragCancelReason = 
      DragCancelReasonNoTarget
    -- ^ There is no suitable drop target.
    | DragCancelReasonUserCancelled
    -- ^ Drag cancelled by the user
    | DragCancelReasonError
    -- ^ Unspecified error.
    | AnotherDragCancelReason Int
    -- ^ Catch-all for unknown values
    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 DragCancelReason
DragCancelReasonNoTarget = Int
0
    fromEnum DragCancelReason
DragCancelReasonUserCancelled = Int
1
    fromEnum DragCancelReason
DragCancelReasonError = Int
2
    fromEnum (AnotherDragCancelReason Int
k) = Int
k

    toEnum :: Int -> DragCancelReason
toEnum Int
0 = DragCancelReason
DragCancelReasonNoTarget
    toEnum Int
1 = DragCancelReason
DragCancelReasonUserCancelled
    toEnum Int
2 = DragCancelReason
DragCancelReasonError
    toEnum Int
k = Int -> DragCancelReason
AnotherDragCancelReason Int
k

instance P.Ord DragCancelReason where
    compare :: DragCancelReason -> DragCancelReason -> Ordering
compare DragCancelReason
a 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)

type instance O.ParentTypes DragCancelReason = '[]
instance O.HasParentTypes DragCancelReason

foreign import ccall "gdk_drag_cancel_reason_get_type" c_gdk_drag_cancel_reason_get_type :: 
    IO GType

instance B.Types.TypedObject DragCancelReason where
    glibType :: IO GType
glibType = IO GType
c_gdk_drag_cancel_reason_get_type

instance B.Types.BoxedEnum DragCancelReason

-- Enum DeviceType
-- | Indicates the device type. See [above][GdkDeviceManager.description]
-- for more information about the meaning of these device types.
data DeviceType = 
      DeviceTypeMaster
    -- ^ Device is a master (or virtual) device. There will
    --                          be an associated focus indicator on the screen.
    | DeviceTypeSlave
    -- ^ Device is a slave (or physical) device.
    | DeviceTypeFloating
    -- ^ Device is a physical device, currently not attached to
    --                            any virtual device.
    | AnotherDeviceType Int
    -- ^ Catch-all for unknown values
    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 DeviceType
DeviceTypeMaster = Int
0
    fromEnum DeviceType
DeviceTypeSlave = Int
1
    fromEnum DeviceType
DeviceTypeFloating = Int
2
    fromEnum (AnotherDeviceType Int
k) = Int
k

    toEnum :: Int -> DeviceType
toEnum Int
0 = DeviceType
DeviceTypeMaster
    toEnum Int
1 = DeviceType
DeviceTypeSlave
    toEnum Int
2 = DeviceType
DeviceTypeFloating
    toEnum Int
k = Int -> DeviceType
AnotherDeviceType Int
k

instance P.Ord DeviceType where
    compare :: DeviceType -> DeviceType -> Ordering
compare DeviceType
a 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)

type instance O.ParentTypes DeviceType = '[]
instance O.HasParentTypes DeviceType

foreign import ccall "gdk_device_type_get_type" c_gdk_device_type_get_type :: 
    IO GType

instance B.Types.TypedObject DeviceType where
    glibType :: IO GType
glibType = IO GType
c_gdk_device_type_get_type

instance B.Types.BoxedEnum DeviceType

-- Enum DeviceToolType
-- | Indicates the specific type of tool being used being a tablet. Such as an
-- airbrush, pencil, etc.
-- 
-- /Since: 3.22/
data DeviceToolType = 
      DeviceToolTypeUnknown
    -- ^ Tool is of an unknown type.
    | DeviceToolTypePen
    -- ^ Tool is a standard tablet stylus.
    | DeviceToolTypeEraser
    -- ^ Tool is standard tablet eraser.
    | DeviceToolTypeBrush
    -- ^ Tool is a brush stylus.
    | DeviceToolTypePencil
    -- ^ Tool is a pencil stylus.
    | DeviceToolTypeAirbrush
    -- ^ Tool is an airbrush stylus.
    | DeviceToolTypeMouse
    -- ^ Tool is a mouse.
    | DeviceToolTypeLens
    -- ^ Tool is a lens cursor.
    | AnotherDeviceToolType Int
    -- ^ Catch-all for unknown values
    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 DeviceToolType
DeviceToolTypeUnknown = Int
0
    fromEnum DeviceToolType
DeviceToolTypePen = Int
1
    fromEnum DeviceToolType
DeviceToolTypeEraser = Int
2
    fromEnum DeviceToolType
DeviceToolTypeBrush = Int
3
    fromEnum DeviceToolType
DeviceToolTypePencil = Int
4
    fromEnum DeviceToolType
DeviceToolTypeAirbrush = Int
5
    fromEnum DeviceToolType
DeviceToolTypeMouse = Int
6
    fromEnum DeviceToolType
DeviceToolTypeLens = Int
7
    fromEnum (AnotherDeviceToolType Int
k) = Int
k

    toEnum :: Int -> DeviceToolType
toEnum Int
0 = DeviceToolType
DeviceToolTypeUnknown
    toEnum Int
1 = DeviceToolType
DeviceToolTypePen
    toEnum Int
2 = DeviceToolType
DeviceToolTypeEraser
    toEnum Int
3 = DeviceToolType
DeviceToolTypeBrush
    toEnum Int
4 = DeviceToolType
DeviceToolTypePencil
    toEnum Int
5 = DeviceToolType
DeviceToolTypeAirbrush
    toEnum Int
6 = DeviceToolType
DeviceToolTypeMouse
    toEnum Int
7 = DeviceToolType
DeviceToolTypeLens
    toEnum Int
k = Int -> DeviceToolType
AnotherDeviceToolType Int
k

instance P.Ord DeviceToolType where
    compare :: DeviceToolType -> DeviceToolType -> Ordering
compare DeviceToolType
a 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)

type instance O.ParentTypes DeviceToolType = '[]
instance O.HasParentTypes DeviceToolType

foreign import ccall "gdk_device_tool_type_get_type" c_gdk_device_tool_type_get_type :: 
    IO GType

instance B.Types.TypedObject DeviceToolType where
    glibType :: IO GType
glibType = IO GType
c_gdk_device_tool_type_get_type

instance B.Types.BoxedEnum DeviceToolType

-- Enum DevicePadFeature
-- | A pad feature.
data DevicePadFeature = 
      DevicePadFeatureButton
    -- ^ a button
    | DevicePadFeatureRing
    -- ^ a ring-shaped interactive area
    | DevicePadFeatureStrip
    -- ^ a straight interactive area
    | AnotherDevicePadFeature Int
    -- ^ Catch-all for unknown values
    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 DevicePadFeature
DevicePadFeatureButton = Int
0
    fromEnum DevicePadFeature
DevicePadFeatureRing = Int
1
    fromEnum DevicePadFeature
DevicePadFeatureStrip = Int
2
    fromEnum (AnotherDevicePadFeature Int
k) = Int
k

    toEnum :: Int -> DevicePadFeature
toEnum Int
0 = DevicePadFeature
DevicePadFeatureButton
    toEnum Int
1 = DevicePadFeature
DevicePadFeatureRing
    toEnum Int
2 = DevicePadFeature
DevicePadFeatureStrip
    toEnum Int
k = Int -> DevicePadFeature
AnotherDevicePadFeature Int
k

instance P.Ord DevicePadFeature where
    compare :: DevicePadFeature -> DevicePadFeature -> Ordering
compare DevicePadFeature
a 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)

type instance O.ParentTypes DevicePadFeature = '[]
instance O.HasParentTypes DevicePadFeature

foreign import ccall "gdk_device_pad_feature_get_type" c_gdk_device_pad_feature_get_type :: 
    IO GType

instance B.Types.TypedObject DevicePadFeature where
    glibType :: IO GType
glibType = IO GType
c_gdk_device_pad_feature_get_type

instance B.Types.BoxedEnum DevicePadFeature

-- Enum CursorType
-- | Predefined cursors.
-- 
-- Note that these IDs are directly taken from the X cursor font, and many
-- of these cursors are either not useful, or are not available on other platforms.
-- 
-- The recommended way to create cursors is to use 'GI.Gdk.Objects.Cursor.cursorNewFromName'.
data CursorType = 
      CursorTypeXCursor
    -- ^ <<http://developer.gnome.org/gdk/stable/X_cursor.png>>
    | CursorTypeArrow
    -- ^ <<http://developer.gnome.org/gdk/stable/arrow.png>>
    | CursorTypeBasedArrowDown
    -- ^ <<http://developer.gnome.org/gdk/stable/based_arrow_down.png>>
    | CursorTypeBasedArrowUp
    -- ^ <<http://developer.gnome.org/gdk/stable/based_arrow_up.png>>
    | CursorTypeBoat
    -- ^ <<http://developer.gnome.org/gdk/stable/boat.png>>
    | CursorTypeBogosity
    -- ^ <<http://developer.gnome.org/gdk/stable/bogosity.png>>
    | CursorTypeBottomLeftCorner
    -- ^ <<http://developer.gnome.org/gdk/stable/bottom_left_corner.png>>
    | CursorTypeBottomRightCorner
    -- ^ <<http://developer.gnome.org/gdk/stable/bottom_right_corner.png>>
    | CursorTypeBottomSide
    -- ^ <<http://developer.gnome.org/gdk/stable/bottom_side.png>>
    | CursorTypeBottomTee
    -- ^ <<http://developer.gnome.org/gdk/stable/bottom_tee.png>>
    | CursorTypeBoxSpiral
    -- ^ <<http://developer.gnome.org/gdk/stable/box_spiral.png>>
    | CursorTypeCenterPtr
    -- ^ <<http://developer.gnome.org/gdk/stable/center_ptr.png>>
    | CursorTypeCircle
    -- ^ <<http://developer.gnome.org/gdk/stable/circle.png>>
    | CursorTypeClock
    -- ^ <<http://developer.gnome.org/gdk/stable/clock.png>>
    | CursorTypeCoffeeMug
    -- ^ <<http://developer.gnome.org/gdk/stable/coffee_mug.png>>
    | CursorTypeCross
    -- ^ <<http://developer.gnome.org/gdk/stable/cross.png>>
    | CursorTypeCrossReverse
    -- ^ <<http://developer.gnome.org/gdk/stable/cross_reverse.png>>
    | CursorTypeCrosshair
    -- ^ <<http://developer.gnome.org/gdk/stable/crosshair.png>>
    | CursorTypeDiamondCross
    -- ^ <<http://developer.gnome.org/gdk/stable/diamond_cross.png>>
    | CursorTypeDot
    -- ^ <<http://developer.gnome.org/gdk/stable/dot.png>>
    | CursorTypeDotbox
    -- ^ <<http://developer.gnome.org/gdk/stable/dotbox.png>>
    | CursorTypeDoubleArrow
    -- ^ <<http://developer.gnome.org/gdk/stable/double_arrow.png>>
    | CursorTypeDraftLarge
    -- ^ <<http://developer.gnome.org/gdk/stable/draft_large.png>>
    | CursorTypeDraftSmall
    -- ^ <<http://developer.gnome.org/gdk/stable/draft_small.png>>
    | CursorTypeDrapedBox
    -- ^ <<http://developer.gnome.org/gdk/stable/draped_box.png>>
    | CursorTypeExchange
    -- ^ <<http://developer.gnome.org/gdk/stable/exchange.png>>
    | CursorTypeFleur
    -- ^ <<http://developer.gnome.org/gdk/stable/fleur.png>>
    | CursorTypeGobbler
    -- ^ <<http://developer.gnome.org/gdk/stable/gobbler.png>>
    | CursorTypeGumby
    -- ^ <<http://developer.gnome.org/gdk/stable/gumby.png>>
    | CursorTypeHand1
    -- ^ <<http://developer.gnome.org/gdk/stable/hand1.png>>
    | CursorTypeHand2
    -- ^ <<http://developer.gnome.org/gdk/stable/hand2.png>>
    | CursorTypeHeart
    -- ^ <<http://developer.gnome.org/gdk/stable/heart.png>>
    | CursorTypeIcon
    -- ^ <<http://developer.gnome.org/gdk/stable/icon.png>>
    | CursorTypeIronCross
    -- ^ <<http://developer.gnome.org/gdk/stable/iron_cross.png>>
    | CursorTypeLeftPtr
    -- ^ <<http://developer.gnome.org/gdk/stable/left_ptr.png>>
    | CursorTypeLeftSide
    -- ^ <<http://developer.gnome.org/gdk/stable/left_side.png>>
    | CursorTypeLeftTee
    -- ^ <<http://developer.gnome.org/gdk/stable/left_tee.png>>
    | CursorTypeLeftbutton
    -- ^ <<http://developer.gnome.org/gdk/stable/leftbutton.png>>
    | CursorTypeLlAngle
    -- ^ <<http://developer.gnome.org/gdk/stable/ll_angle.png>>
    | CursorTypeLrAngle
    -- ^ <<http://developer.gnome.org/gdk/stable/lr_angle.png>>
    | CursorTypeMan
    -- ^ <<http://developer.gnome.org/gdk/stable/man.png>>
    | CursorTypeMiddlebutton
    -- ^ <<http://developer.gnome.org/gdk/stable/middlebutton.png>>
    | CursorTypeMouse
    -- ^ <<http://developer.gnome.org/gdk/stable/mouse.png>>
    | CursorTypePencil
    -- ^ <<http://developer.gnome.org/gdk/stable/pencil.png>>
    | CursorTypePirate
    -- ^ <<http://developer.gnome.org/gdk/stable/pirate.png>>
    | CursorTypePlus
    -- ^ <<http://developer.gnome.org/gdk/stable/plus.png>>
    | CursorTypeQuestionArrow
    -- ^ <<http://developer.gnome.org/gdk/stable/question_arrow.png>>
    | CursorTypeRightPtr
    -- ^ <<http://developer.gnome.org/gdk/stable/right_ptr.png>>
    | CursorTypeRightSide
    -- ^ <<http://developer.gnome.org/gdk/stable/right_side.png>>
    | CursorTypeRightTee
    -- ^ <<http://developer.gnome.org/gdk/stable/right_tee.png>>
    | CursorTypeRightbutton
    -- ^ <<http://developer.gnome.org/gdk/stable/rightbutton.png>>
    | CursorTypeRtlLogo
    -- ^ <<http://developer.gnome.org/gdk/stable/rtl_logo.png>>
    | CursorTypeSailboat
    -- ^ <<http://developer.gnome.org/gdk/stable/sailboat.png>>
    | CursorTypeSbDownArrow
    -- ^ <<http://developer.gnome.org/gdk/stable/sb_down_arrow.png>>
    | CursorTypeSbHDoubleArrow
    -- ^ <<http://developer.gnome.org/gdk/stable/sb_h_double_arrow.png>>
    | CursorTypeSbLeftArrow
    -- ^ <<http://developer.gnome.org/gdk/stable/sb_left_arrow.png>>
    | CursorTypeSbRightArrow
    -- ^ <<http://developer.gnome.org/gdk/stable/sb_right_arrow.png>>
    | CursorTypeSbUpArrow
    -- ^ <<http://developer.gnome.org/gdk/stable/sb_up_arrow.png>>
    | CursorTypeSbVDoubleArrow
    -- ^ <<http://developer.gnome.org/gdk/stable/sb_v_double_arrow.png>>
    | CursorTypeShuttle
    -- ^ <<http://developer.gnome.org/gdk/stable/shuttle.png>>
    | CursorTypeSizing
    -- ^ <<http://developer.gnome.org/gdk/stable/sizing.png>>
    | CursorTypeSpider
    -- ^ <<http://developer.gnome.org/gdk/stable/spider.png>>
    | CursorTypeSpraycan
    -- ^ <<http://developer.gnome.org/gdk/stable/spraycan.png>>
    | CursorTypeStar
    -- ^ <<http://developer.gnome.org/gdk/stable/star.png>>
    | CursorTypeTarget
    -- ^ <<http://developer.gnome.org/gdk/stable/target.png>>
    | CursorTypeTcross
    -- ^ <<http://developer.gnome.org/gdk/stable/tcross.png>>
    | CursorTypeTopLeftArrow
    -- ^ <<http://developer.gnome.org/gdk/stable/top_left_arrow.png>>
    | CursorTypeTopLeftCorner
    -- ^ <<http://developer.gnome.org/gdk/stable/top_left_corner.png>>
    | CursorTypeTopRightCorner
    -- ^ <<http://developer.gnome.org/gdk/stable/top_right_corner.png>>
    | CursorTypeTopSide
    -- ^ <<http://developer.gnome.org/gdk/stable/top_side.png>>
    | CursorTypeTopTee
    -- ^ <<http://developer.gnome.org/gdk/stable/top_tee.png>>
    | CursorTypeTrek
    -- ^ <<http://developer.gnome.org/gdk/stable/trek.png>>
    | CursorTypeUlAngle
    -- ^ <<http://developer.gnome.org/gdk/stable/ul_angle.png>>
    | CursorTypeUmbrella
    -- ^ <<http://developer.gnome.org/gdk/stable/umbrella.png>>
    | CursorTypeUrAngle
    -- ^ <<http://developer.gnome.org/gdk/stable/ur_angle.png>>
    | CursorTypeWatch
    -- ^ <<http://developer.gnome.org/gdk/stable/watch.png>>
    | CursorTypeXterm
    -- ^ <<http://developer.gnome.org/gdk/stable/xterm.png>>
    | CursorTypeLastCursor
    -- ^ last cursor type
    | CursorTypeBlankCursor
    -- ^ Blank cursor. Since 2.16
    | CursorTypeCursorIsPixmap
    -- ^ type of cursors constructed with
    --   'GI.Gdk.Objects.Cursor.cursorNewFromPixbuf'
    | AnotherCursorType Int
    -- ^ Catch-all for unknown values
    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 CursorType
CursorTypeXCursor = Int
0
    fromEnum CursorType
CursorTypeArrow = Int
2
    fromEnum CursorType
CursorTypeBasedArrowDown = Int
4
    fromEnum CursorType
CursorTypeBasedArrowUp = Int
6
    fromEnum CursorType
CursorTypeBoat = Int
8
    fromEnum CursorType
CursorTypeBogosity = Int
10
    fromEnum CursorType
CursorTypeBottomLeftCorner = Int
12
    fromEnum CursorType
CursorTypeBottomRightCorner = Int
14
    fromEnum CursorType
CursorTypeBottomSide = Int
16
    fromEnum CursorType
CursorTypeBottomTee = Int
18
    fromEnum CursorType
CursorTypeBoxSpiral = Int
20
    fromEnum CursorType
CursorTypeCenterPtr = Int
22
    fromEnum CursorType
CursorTypeCircle = Int
24
    fromEnum CursorType
CursorTypeClock = Int
26
    fromEnum CursorType
CursorTypeCoffeeMug = Int
28
    fromEnum CursorType
CursorTypeCross = Int
30
    fromEnum CursorType
CursorTypeCrossReverse = Int
32
    fromEnum CursorType
CursorTypeCrosshair = Int
34
    fromEnum CursorType
CursorTypeDiamondCross = Int
36
    fromEnum CursorType
CursorTypeDot = Int
38
    fromEnum CursorType
CursorTypeDotbox = Int
40
    fromEnum CursorType
CursorTypeDoubleArrow = Int
42
    fromEnum CursorType
CursorTypeDraftLarge = Int
44
    fromEnum CursorType
CursorTypeDraftSmall = Int
46
    fromEnum CursorType
CursorTypeDrapedBox = Int
48
    fromEnum CursorType
CursorTypeExchange = Int
50
    fromEnum CursorType
CursorTypeFleur = Int
52
    fromEnum CursorType
CursorTypeGobbler = Int
54
    fromEnum CursorType
CursorTypeGumby = Int
56
    fromEnum CursorType
CursorTypeHand1 = Int
58
    fromEnum CursorType
CursorTypeHand2 = Int
60
    fromEnum CursorType
CursorTypeHeart = Int
62
    fromEnum CursorType
CursorTypeIcon = Int
64
    fromEnum CursorType
CursorTypeIronCross = Int
66
    fromEnum CursorType
CursorTypeLeftPtr = Int
68
    fromEnum CursorType
CursorTypeLeftSide = Int
70
    fromEnum CursorType
CursorTypeLeftTee = Int
72
    fromEnum CursorType
CursorTypeLeftbutton = Int
74
    fromEnum CursorType
CursorTypeLlAngle = Int
76
    fromEnum CursorType
CursorTypeLrAngle = Int
78
    fromEnum CursorType
CursorTypeMan = Int
80
    fromEnum CursorType
CursorTypeMiddlebutton = Int
82
    fromEnum CursorType
CursorTypeMouse = Int
84
    fromEnum CursorType
CursorTypePencil = Int
86
    fromEnum CursorType
CursorTypePirate = Int
88
    fromEnum CursorType
CursorTypePlus = Int
90
    fromEnum CursorType
CursorTypeQuestionArrow = Int
92
    fromEnum CursorType
CursorTypeRightPtr = Int
94
    fromEnum CursorType
CursorTypeRightSide = Int
96
    fromEnum CursorType
CursorTypeRightTee = Int
98
    fromEnum CursorType
CursorTypeRightbutton = Int
100
    fromEnum CursorType
CursorTypeRtlLogo = Int
102
    fromEnum CursorType
CursorTypeSailboat = Int
104
    fromEnum CursorType
CursorTypeSbDownArrow = Int
106
    fromEnum CursorType
CursorTypeSbHDoubleArrow = Int
108
    fromEnum CursorType
CursorTypeSbLeftArrow = Int
110
    fromEnum CursorType
CursorTypeSbRightArrow = Int
112
    fromEnum CursorType
CursorTypeSbUpArrow = Int
114
    fromEnum CursorType
CursorTypeSbVDoubleArrow = Int
116
    fromEnum CursorType
CursorTypeShuttle = Int
118
    fromEnum CursorType
CursorTypeSizing = Int
120
    fromEnum CursorType
CursorTypeSpider = Int
122
    fromEnum CursorType
CursorTypeSpraycan = Int
124
    fromEnum CursorType
CursorTypeStar = Int
126
    fromEnum CursorType
CursorTypeTarget = Int
128
    fromEnum CursorType
CursorTypeTcross = Int
130
    fromEnum CursorType
CursorTypeTopLeftArrow = Int
132
    fromEnum CursorType
CursorTypeTopLeftCorner = Int
134
    fromEnum CursorType
CursorTypeTopRightCorner = Int
136
    fromEnum CursorType
CursorTypeTopSide = Int
138
    fromEnum CursorType
CursorTypeTopTee = Int
140
    fromEnum CursorType
CursorTypeTrek = Int
142
    fromEnum CursorType
CursorTypeUlAngle = Int
144
    fromEnum CursorType
CursorTypeUmbrella = Int
146
    fromEnum CursorType
CursorTypeUrAngle = Int
148
    fromEnum CursorType
CursorTypeWatch = Int
150
    fromEnum CursorType
CursorTypeXterm = Int
152
    fromEnum CursorType
CursorTypeLastCursor = Int
153
    fromEnum CursorType
CursorTypeBlankCursor = Int
-2
    fromEnum CursorType
CursorTypeCursorIsPixmap = Int
-1
    fromEnum (AnotherCursorType Int
k) = Int
k

    toEnum :: Int -> CursorType
toEnum Int
0 = CursorType
CursorTypeXCursor
    toEnum Int
2 = CursorType
CursorTypeArrow
    toEnum Int
4 = CursorType
CursorTypeBasedArrowDown
    toEnum Int
6 = CursorType
CursorTypeBasedArrowUp
    toEnum Int
8 = CursorType
CursorTypeBoat
    toEnum Int
10 = CursorType
CursorTypeBogosity
    toEnum Int
12 = CursorType
CursorTypeBottomLeftCorner
    toEnum Int
14 = CursorType
CursorTypeBottomRightCorner
    toEnum Int
16 = CursorType
CursorTypeBottomSide
    toEnum Int
18 = CursorType
CursorTypeBottomTee
    toEnum Int
20 = CursorType
CursorTypeBoxSpiral
    toEnum Int
22 = CursorType
CursorTypeCenterPtr
    toEnum Int
24 = CursorType
CursorTypeCircle
    toEnum Int
26 = CursorType
CursorTypeClock
    toEnum Int
28 = CursorType
CursorTypeCoffeeMug
    toEnum Int
30 = CursorType
CursorTypeCross
    toEnum Int
32 = CursorType
CursorTypeCrossReverse
    toEnum Int
34 = CursorType
CursorTypeCrosshair
    toEnum Int
36 = CursorType
CursorTypeDiamondCross
    toEnum Int
38 = CursorType
CursorTypeDot
    toEnum Int
40 = CursorType
CursorTypeDotbox
    toEnum Int
42 = CursorType
CursorTypeDoubleArrow
    toEnum Int
44 = CursorType
CursorTypeDraftLarge
    toEnum Int
46 = CursorType
CursorTypeDraftSmall
    toEnum Int
48 = CursorType
CursorTypeDrapedBox
    toEnum Int
50 = CursorType
CursorTypeExchange
    toEnum Int
52 = CursorType
CursorTypeFleur
    toEnum Int
54 = CursorType
CursorTypeGobbler
    toEnum Int
56 = CursorType
CursorTypeGumby
    toEnum Int
58 = CursorType
CursorTypeHand1
    toEnum Int
60 = CursorType
CursorTypeHand2
    toEnum Int
62 = CursorType
CursorTypeHeart
    toEnum Int
64 = CursorType
CursorTypeIcon
    toEnum Int
66 = CursorType
CursorTypeIronCross
    toEnum Int
68 = CursorType
CursorTypeLeftPtr
    toEnum Int
70 = CursorType
CursorTypeLeftSide
    toEnum Int
72 = CursorType
CursorTypeLeftTee
    toEnum Int
74 = CursorType
CursorTypeLeftbutton
    toEnum Int
76 = CursorType
CursorTypeLlAngle
    toEnum Int
78 = CursorType
CursorTypeLrAngle
    toEnum Int
80 = CursorType
CursorTypeMan
    toEnum Int
82 = CursorType
CursorTypeMiddlebutton
    toEnum Int
84 = CursorType
CursorTypeMouse
    toEnum Int
86 = CursorType
CursorTypePencil
    toEnum Int
88 = CursorType
CursorTypePirate
    toEnum Int
90 = CursorType
CursorTypePlus
    toEnum Int
92 = CursorType
CursorTypeQuestionArrow
    toEnum Int
94 = CursorType
CursorTypeRightPtr
    toEnum Int
96 = CursorType
CursorTypeRightSide
    toEnum Int
98 = CursorType
CursorTypeRightTee
    toEnum Int
100 = CursorType
CursorTypeRightbutton
    toEnum Int
102 = CursorType
CursorTypeRtlLogo
    toEnum Int
104 = CursorType
CursorTypeSailboat
    toEnum Int
106 = CursorType
CursorTypeSbDownArrow
    toEnum Int
108 = CursorType
CursorTypeSbHDoubleArrow
    toEnum Int
110 = CursorType
CursorTypeSbLeftArrow
    toEnum Int
112 = CursorType
CursorTypeSbRightArrow
    toEnum Int
114 = CursorType
CursorTypeSbUpArrow
    toEnum Int
116 = CursorType
CursorTypeSbVDoubleArrow
    toEnum Int
118 = CursorType
CursorTypeShuttle
    toEnum Int
120 = CursorType
CursorTypeSizing
    toEnum Int
122 = CursorType
CursorTypeSpider
    toEnum Int
124 = CursorType
CursorTypeSpraycan
    toEnum Int
126 = CursorType
CursorTypeStar
    toEnum Int
128 = CursorType
CursorTypeTarget
    toEnum Int
130 = CursorType
CursorTypeTcross
    toEnum Int
132 = CursorType
CursorTypeTopLeftArrow
    toEnum Int
134 = CursorType
CursorTypeTopLeftCorner
    toEnum Int
136 = CursorType
CursorTypeTopRightCorner
    toEnum Int
138 = CursorType
CursorTypeTopSide
    toEnum Int
140 = CursorType
CursorTypeTopTee
    toEnum Int
142 = CursorType
CursorTypeTrek
    toEnum Int
144 = CursorType
CursorTypeUlAngle
    toEnum Int
146 = CursorType
CursorTypeUmbrella
    toEnum Int
148 = CursorType
CursorTypeUrAngle
    toEnum Int
150 = CursorType
CursorTypeWatch
    toEnum Int
152 = CursorType
CursorTypeXterm
    toEnum Int
153 = CursorType
CursorTypeLastCursor
    toEnum Int
-2 = CursorType
CursorTypeBlankCursor
    toEnum Int
-1 = CursorType
CursorTypeCursorIsPixmap
    toEnum Int
k = Int -> CursorType
AnotherCursorType Int
k

instance P.Ord CursorType where
    compare :: CursorType -> CursorType -> Ordering
compare CursorType
a 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)

type instance O.ParentTypes CursorType = '[]
instance O.HasParentTypes CursorType

foreign import ccall "gdk_cursor_type_get_type" c_gdk_cursor_type_get_type :: 
    IO GType

instance B.Types.TypedObject CursorType where
    glibType :: IO GType
glibType = IO GType
c_gdk_cursor_type_get_type

instance B.Types.BoxedEnum CursorType

-- Enum CrossingMode
-- | Specifies the crossing mode for t'GI.Gdk.Structs.EventCrossing.EventCrossing'.
data CrossingMode = 
      CrossingModeNormal
    -- ^ crossing because of pointer motion.
    | CrossingModeGrab
    -- ^ crossing because a grab is activated.
    | CrossingModeUngrab
    -- ^ crossing because a grab is deactivated.
    | CrossingModeGtkGrab
    -- ^ crossing because a GTK+ grab is activated.
    | CrossingModeGtkUngrab
    -- ^ crossing because a GTK+ grab is deactivated.
    | CrossingModeStateChanged
    -- ^ crossing because a GTK+ widget changed
    --   state (e.g. sensitivity).
    | CrossingModeTouchBegin
    -- ^ crossing because a touch sequence has begun,
    --   this event is synthetic as the pointer might have not left the window.
    | CrossingModeTouchEnd
    -- ^ crossing because a touch sequence has ended,
    --   this event is synthetic as the pointer might have not left the window.
    | CrossingModeDeviceSwitch
    -- ^ crossing because of a device switch (i.e.
    --   a mouse taking control of the pointer after a touch device), this event
    --   is synthetic as the pointer didn’t leave the window.
    | AnotherCrossingMode Int
    -- ^ Catch-all for unknown values
    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 CrossingMode
CrossingModeNormal = Int
0
    fromEnum CrossingMode
CrossingModeGrab = Int
1
    fromEnum CrossingMode
CrossingModeUngrab = Int
2
    fromEnum CrossingMode
CrossingModeGtkGrab = Int
3
    fromEnum CrossingMode
CrossingModeGtkUngrab = Int
4
    fromEnum CrossingMode
CrossingModeStateChanged = Int
5
    fromEnum CrossingMode
CrossingModeTouchBegin = Int
6
    fromEnum CrossingMode
CrossingModeTouchEnd = Int
7
    fromEnum CrossingMode
CrossingModeDeviceSwitch = Int
8
    fromEnum (AnotherCrossingMode Int
k) = Int
k

    toEnum :: Int -> CrossingMode
toEnum Int
0 = CrossingMode
CrossingModeNormal
    toEnum Int
1 = CrossingMode
CrossingModeGrab
    toEnum Int
2 = CrossingMode
CrossingModeUngrab
    toEnum Int
3 = CrossingMode
CrossingModeGtkGrab
    toEnum Int
4 = CrossingMode
CrossingModeGtkUngrab
    toEnum Int
5 = CrossingMode
CrossingModeStateChanged
    toEnum Int
6 = CrossingMode
CrossingModeTouchBegin
    toEnum Int
7 = CrossingMode
CrossingModeTouchEnd
    toEnum Int
8 = CrossingMode
CrossingModeDeviceSwitch
    toEnum Int
k = Int -> CrossingMode
AnotherCrossingMode Int
k

instance P.Ord CrossingMode where
    compare :: CrossingMode -> CrossingMode -> Ordering
compare CrossingMode
a 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)

type instance O.ParentTypes CrossingMode = '[]
instance O.HasParentTypes CrossingMode

foreign import ccall "gdk_crossing_mode_get_type" c_gdk_crossing_mode_get_type :: 
    IO GType

instance B.Types.TypedObject CrossingMode where
    glibType :: IO GType
glibType = IO GType
c_gdk_crossing_mode_get_type

instance B.Types.BoxedEnum CrossingMode

-- Enum ByteOrder
-- | A set of values describing the possible byte-orders
-- for storing pixel values in memory.
data ByteOrder = 
      ByteOrderLsbFirst
    -- ^ The values are stored with the least-significant byte
    --   first. For instance, the 32-bit value 0xffeecc would be stored
    --   in memory as 0xcc, 0xee, 0xff, 0x00.
    | ByteOrderMsbFirst
    -- ^ The values are stored with the most-significant byte
    --   first. For instance, the 32-bit value 0xffeecc would be stored
    --   in memory as 0x00, 0xff, 0xee, 0xcc.
    | AnotherByteOrder Int
    -- ^ Catch-all for unknown values
    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 ByteOrder
ByteOrderLsbFirst = Int
0
    fromEnum ByteOrder
ByteOrderMsbFirst = Int
1
    fromEnum (AnotherByteOrder Int
k) = Int
k

    toEnum :: Int -> ByteOrder
toEnum Int
0 = ByteOrder
ByteOrderLsbFirst
    toEnum Int
1 = ByteOrder
ByteOrderMsbFirst
    toEnum Int
k = Int -> ByteOrder
AnotherByteOrder Int
k

instance P.Ord ByteOrder where
    compare :: ByteOrder -> ByteOrder -> Ordering
compare ByteOrder
a 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)

type instance O.ParentTypes ByteOrder = '[]
instance O.HasParentTypes ByteOrder

foreign import ccall "gdk_byte_order_get_type" c_gdk_byte_order_get_type :: 
    IO GType

instance B.Types.TypedObject ByteOrder where
    glibType :: IO GType
glibType = IO GType
c_gdk_byte_order_get_type

instance B.Types.BoxedEnum ByteOrder

-- Enum AxisUse
-- | An enumeration describing the way in which a device
-- axis (valuator) maps onto the predefined valuator
-- types that GTK+ understands.
-- 
-- Note that the X and Y axes are not really needed; pointer devices
-- report their location via the x\/y members of events regardless. Whether
-- X and Y are present as axes depends on the GDK backend.
data AxisUse = 
      AxisUseIgnore
    -- ^ the axis is ignored.
    | AxisUseX
    -- ^ the axis is used as the x axis.
    | AxisUseY
    -- ^ the axis is used as the y axis.
    | AxisUsePressure
    -- ^ the axis is used for pressure information.
    | AxisUseXtilt
    -- ^ the axis is used for x tilt information.
    | AxisUseYtilt
    -- ^ the axis is used for y tilt information.
    | AxisUseWheel
    -- ^ the axis is used for wheel information.
    | AxisUseDistance
    -- ^ the axis is used for pen\/tablet distance information. (Since: 3.22)
    | AxisUseRotation
    -- ^ the axis is used for pen rotation information. (Since: 3.22)
    | AxisUseSlider
    -- ^ the axis is used for pen slider information. (Since: 3.22)
    | AxisUseLast
    -- ^ a constant equal to the numerically highest axis value.
    | AnotherAxisUse Int
    -- ^ Catch-all for unknown values
    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 AxisUse
AxisUseIgnore = Int
0
    fromEnum AxisUse
AxisUseX = Int
1
    fromEnum AxisUse
AxisUseY = Int
2
    fromEnum AxisUse
AxisUsePressure = Int
3
    fromEnum AxisUse
AxisUseXtilt = Int
4
    fromEnum AxisUse
AxisUseYtilt = Int
5
    fromEnum AxisUse
AxisUseWheel = Int
6
    fromEnum AxisUse
AxisUseDistance = Int
7
    fromEnum AxisUse
AxisUseRotation = Int
8
    fromEnum AxisUse
AxisUseSlider = Int
9
    fromEnum AxisUse
AxisUseLast = Int
10
    fromEnum (AnotherAxisUse Int
k) = Int
k

    toEnum :: Int -> AxisUse
toEnum Int
0 = AxisUse
AxisUseIgnore
    toEnum Int
1 = AxisUse
AxisUseX
    toEnum Int
2 = AxisUse
AxisUseY
    toEnum Int
3 = AxisUse
AxisUsePressure
    toEnum Int
4 = AxisUse
AxisUseXtilt
    toEnum Int
5 = AxisUse
AxisUseYtilt
    toEnum Int
6 = AxisUse
AxisUseWheel
    toEnum Int
7 = AxisUse
AxisUseDistance
    toEnum Int
8 = AxisUse
AxisUseRotation
    toEnum Int
9 = AxisUse
AxisUseSlider
    toEnum Int
10 = AxisUse
AxisUseLast
    toEnum Int
k = Int -> AxisUse
AnotherAxisUse Int
k

instance P.Ord AxisUse where
    compare :: AxisUse -> AxisUse -> Ordering
compare AxisUse
a 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)

type instance O.ParentTypes AxisUse = '[]
instance O.HasParentTypes AxisUse

foreign import ccall "gdk_axis_use_get_type" c_gdk_axis_use_get_type :: 
    IO GType

instance B.Types.TypedObject AxisUse where
    glibType :: IO GType
glibType = IO GType
c_gdk_axis_use_get_type

instance B.Types.BoxedEnum AxisUse