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

    #if !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.GArray as B.GArray
    import qualified Data.GI.Base.GClosure as B.GClosure
    import qualified Data.GI.Base.GError as B.GError
    import qualified Data.GI.Base.GHashTable as B.GHT
    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.Coerce as Coerce
    import qualified Data.Text as T
    import qualified Data.Kind as DK
    import qualified Data.ByteString.Char8 as B
    import qualified Data.Map as Map
    import qualified Foreign.Ptr as FP
    import qualified GHC.OverloadedLabels as OL
    import qualified GHC.Records as R

    -- 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
    $cshowsPrec :: Int -> WindowWindowClass -> ShowS
    showsPrec :: Int -> WindowWindowClass -> ShowS
    $cshow :: WindowWindowClass -> String
    show :: WindowWindowClass -> String
    $cshowList :: [WindowWindowClass] -> ShowS
    showList :: [WindowWindowClass] -> ShowS
    Show, WindowWindowClass -> WindowWindowClass -> Bool
    (WindowWindowClass -> WindowWindowClass -> Bool)
    -> (WindowWindowClass -> WindowWindowClass -> Bool)
    -> Eq WindowWindowClass
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: WindowWindowClass -> WindowWindowClass -> Bool
    == :: WindowWindowClass -> WindowWindowClass -> Bool
    $c/= :: WindowWindowClass -> WindowWindowClass -> Bool
    /= :: 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
    $cshowsPrec :: Int -> WindowTypeHint -> ShowS
    showsPrec :: Int -> WindowTypeHint -> ShowS
    $cshow :: WindowTypeHint -> String
    show :: WindowTypeHint -> String
    $cshowList :: [WindowTypeHint] -> ShowS
    showList :: [WindowTypeHint] -> ShowS
    Show, WindowTypeHint -> WindowTypeHint -> Bool
    (WindowTypeHint -> WindowTypeHint -> Bool)
    -> (WindowTypeHint -> WindowTypeHint -> Bool) -> Eq WindowTypeHint
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: WindowTypeHint -> WindowTypeHint -> Bool
    == :: WindowTypeHint -> WindowTypeHint -> Bool
    $c/= :: WindowTypeHint -> WindowTypeHint -> Bool
    /= :: 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
    $cshowsPrec :: Int -> WindowType -> ShowS
    showsPrec :: Int -> WindowType -> ShowS
    $cshow :: WindowType -> String
    show :: WindowType -> String
    $cshowList :: [WindowType] -> ShowS
    showList :: [WindowType] -> ShowS
    Show, WindowType -> WindowType -> Bool
    (WindowType -> WindowType -> Bool)
    -> (WindowType -> WindowType -> Bool) -> Eq WindowType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: WindowType -> WindowType -> Bool
    == :: WindowType -> WindowType -> Bool
    $c/= :: WindowType -> WindowType -> Bool
    /= :: 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
    $cshowsPrec :: Int -> WindowEdge -> ShowS
    showsPrec :: Int -> WindowEdge -> ShowS
    $cshow :: WindowEdge -> String
    show :: WindowEdge -> String
    $cshowList :: [WindowEdge] -> ShowS
    showList :: [WindowEdge] -> ShowS
    Show, WindowEdge -> WindowEdge -> Bool
    (WindowEdge -> WindowEdge -> Bool)
    -> (WindowEdge -> WindowEdge -> Bool) -> Eq WindowEdge
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: WindowEdge -> WindowEdge -> Bool
    == :: WindowEdge -> WindowEdge -> Bool
    $c/= :: WindowEdge -> WindowEdge -> Bool
    /= :: 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
    $cshowsPrec :: Int -> VisualType -> ShowS
    showsPrec :: Int -> VisualType -> ShowS
    $cshow :: VisualType -> String
    show :: VisualType -> String
    $cshowList :: [VisualType] -> ShowS
    showList :: [VisualType] -> ShowS
    Show, VisualType -> VisualType -> Bool
    (VisualType -> VisualType -> Bool)
    -> (VisualType -> VisualType -> Bool) -> Eq VisualType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: VisualType -> VisualType -> Bool
    == :: VisualType -> VisualType -> Bool
    $c/= :: VisualType -> VisualType -> Bool
    /= :: 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
    $cshowsPrec :: Int -> VisibilityState -> ShowS
    showsPrec :: Int -> VisibilityState -> ShowS
    $cshow :: VisibilityState -> String
    show :: VisibilityState -> String
    $cshowList :: [VisibilityState] -> ShowS
    showList :: [VisibilityState] -> ShowS
    Show, VisibilityState -> VisibilityState -> Bool
    (VisibilityState -> VisibilityState -> Bool)
    -> (VisibilityState -> VisibilityState -> Bool)
    -> Eq VisibilityState
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: VisibilityState -> VisibilityState -> Bool
    == :: VisibilityState -> VisibilityState -> Bool
    $c/= :: VisibilityState -> VisibilityState -> Bool
    /= :: 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
    $cshowsPrec :: Int -> TouchpadGesturePhase -> ShowS
    showsPrec :: Int -> TouchpadGesturePhase -> ShowS
    $cshow :: TouchpadGesturePhase -> String
    show :: TouchpadGesturePhase -> String
    $cshowList :: [TouchpadGesturePhase] -> ShowS
    showList :: [TouchpadGesturePhase] -> ShowS
    Show, TouchpadGesturePhase -> TouchpadGesturePhase -> Bool
    (TouchpadGesturePhase -> TouchpadGesturePhase -> Bool)
    -> (TouchpadGesturePhase -> TouchpadGesturePhase -> Bool)
    -> Eq TouchpadGesturePhase
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: TouchpadGesturePhase -> TouchpadGesturePhase -> Bool
    == :: TouchpadGesturePhase -> TouchpadGesturePhase -> Bool
    $c/= :: TouchpadGesturePhase -> TouchpadGesturePhase -> Bool
    /= :: 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
    $cshowsPrec :: Int -> SubpixelLayout -> ShowS
    showsPrec :: Int -> SubpixelLayout -> ShowS
    $cshow :: SubpixelLayout -> String
    show :: SubpixelLayout -> String
    $cshowList :: [SubpixelLayout] -> ShowS
    showList :: [SubpixelLayout] -> ShowS
    Show, SubpixelLayout -> SubpixelLayout -> Bool
    (SubpixelLayout -> SubpixelLayout -> Bool)
    -> (SubpixelLayout -> SubpixelLayout -> Bool) -> Eq SubpixelLayout
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: SubpixelLayout -> SubpixelLayout -> Bool
    == :: SubpixelLayout -> SubpixelLayout -> Bool
    $c/= :: SubpixelLayout -> SubpixelLayout -> Bool
    /= :: 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
    $cshowsPrec :: Int -> Status -> ShowS
    showsPrec :: Int -> Status -> ShowS
    $cshow :: Status -> String
    show :: Status -> String
    $cshowList :: [Status] -> ShowS
    showList :: [Status] -> ShowS
    Show, Status -> Status -> Bool
    (Status -> Status -> Bool)
    -> (Status -> Status -> Bool) -> Eq Status
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Status -> Status -> Bool
    == :: Status -> Status -> Bool
    $c/= :: Status -> Status -> Bool
    /= :: 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
    $cshowsPrec :: Int -> SettingAction -> ShowS
    showsPrec :: Int -> SettingAction -> ShowS
    $cshow :: SettingAction -> String
    show :: SettingAction -> String
    $cshowList :: [SettingAction] -> ShowS
    showList :: [SettingAction] -> ShowS
    Show, SettingAction -> SettingAction -> Bool
    (SettingAction -> SettingAction -> Bool)
    -> (SettingAction -> SettingAction -> Bool) -> Eq SettingAction
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: SettingAction -> SettingAction -> Bool
    == :: SettingAction -> SettingAction -> Bool
    $c/= :: SettingAction -> SettingAction -> Bool
    /= :: 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
    $cshowsPrec :: Int -> ScrollDirection -> ShowS
    showsPrec :: Int -> ScrollDirection -> ShowS
    $cshow :: ScrollDirection -> String
    show :: ScrollDirection -> String
    $cshowList :: [ScrollDirection] -> ShowS
    showList :: [ScrollDirection] -> ShowS
    Show, ScrollDirection -> ScrollDirection -> Bool
    (ScrollDirection -> ScrollDirection -> Bool)
    -> (ScrollDirection -> ScrollDirection -> Bool)
    -> Eq ScrollDirection
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ScrollDirection -> ScrollDirection -> Bool
    == :: ScrollDirection -> ScrollDirection -> Bool
    $c/= :: ScrollDirection -> ScrollDirection -> Bool
    /= :: 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
    $cshowsPrec :: Int -> PropertyState -> ShowS
    showsPrec :: Int -> PropertyState -> ShowS
    $cshow :: PropertyState -> String
    show :: PropertyState -> String
    $cshowList :: [PropertyState] -> ShowS
    showList :: [PropertyState] -> ShowS
    Show, PropertyState -> PropertyState -> Bool
    (PropertyState -> PropertyState -> Bool)
    -> (PropertyState -> PropertyState -> Bool) -> Eq PropertyState
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: PropertyState -> PropertyState -> Bool
    == :: PropertyState -> PropertyState -> Bool
    $c/= :: PropertyState -> PropertyState -> Bool
    /= :: 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
    $cshowsPrec :: Int -> PropMode -> ShowS
    showsPrec :: Int -> PropMode -> ShowS
    $cshow :: PropMode -> String
    show :: PropMode -> String
    $cshowList :: [PropMode] -> ShowS
    showList :: [PropMode] -> ShowS
    Show, PropMode -> PropMode -> Bool
    (PropMode -> PropMode -> Bool)
    -> (PropMode -> PropMode -> Bool) -> Eq PropMode
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: PropMode -> PropMode -> Bool
    == :: PropMode -> PropMode -> Bool
    $c/= :: PropMode -> PropMode -> Bool
    /= :: 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
    $cshowsPrec :: Int -> OwnerChange -> ShowS
    showsPrec :: Int -> OwnerChange -> ShowS
    $cshow :: OwnerChange -> String
    show :: OwnerChange -> String
    $cshowList :: [OwnerChange] -> ShowS
    showList :: [OwnerChange] -> ShowS
    Show, OwnerChange -> OwnerChange -> Bool
    (OwnerChange -> OwnerChange -> Bool)
    -> (OwnerChange -> OwnerChange -> Bool) -> Eq OwnerChange
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: OwnerChange -> OwnerChange -> Bool
    == :: OwnerChange -> OwnerChange -> Bool
    $c/= :: OwnerChange -> OwnerChange -> Bool
    /= :: 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
    $cshowsPrec :: Int -> NotifyType -> ShowS
    showsPrec :: Int -> NotifyType -> ShowS
    $cshow :: NotifyType -> String
    show :: NotifyType -> String
    $cshowList :: [NotifyType] -> ShowS
    showList :: [NotifyType] -> ShowS
    Show, NotifyType -> NotifyType -> Bool
    (NotifyType -> NotifyType -> Bool)
    -> (NotifyType -> NotifyType -> Bool) -> Eq NotifyType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: NotifyType -> NotifyType -> Bool
    == :: NotifyType -> NotifyType -> Bool
    $c/= :: NotifyType -> NotifyType -> Bool
    /= :: 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
    $cshowsPrec :: Int -> ModifierIntent -> ShowS
    showsPrec :: Int -> ModifierIntent -> ShowS
    $cshow :: ModifierIntent -> String
    show :: ModifierIntent -> String
    $cshowList :: [ModifierIntent] -> ShowS
    showList :: [ModifierIntent] -> ShowS
    Show, ModifierIntent -> ModifierIntent -> Bool
    (ModifierIntent -> ModifierIntent -> Bool)
    -> (ModifierIntent -> ModifierIntent -> Bool) -> Eq ModifierIntent
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ModifierIntent -> ModifierIntent -> Bool
    == :: ModifierIntent -> ModifierIntent -> Bool
    $c/= :: ModifierIntent -> ModifierIntent -> Bool
    /= :: 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
    $cshowsPrec :: Int -> InputSource -> ShowS
    showsPrec :: Int -> InputSource -> ShowS
    $cshow :: InputSource -> String
    show :: InputSource -> String
    $cshowList :: [InputSource] -> ShowS
    showList :: [InputSource] -> ShowS
    Show, InputSource -> InputSource -> Bool
    (InputSource -> InputSource -> Bool)
    -> (InputSource -> InputSource -> Bool) -> Eq InputSource
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: InputSource -> InputSource -> Bool
    == :: InputSource -> InputSource -> Bool
    $c/= :: InputSource -> InputSource -> Bool
    /= :: 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
    $cshowsPrec :: Int -> InputMode -> ShowS
    showsPrec :: Int -> InputMode -> ShowS
    $cshow :: InputMode -> String
    show :: InputMode -> String
    $cshowList :: [InputMode] -> ShowS
    showList :: [InputMode] -> ShowS
    Show, InputMode -> InputMode -> Bool
    (InputMode -> InputMode -> Bool)
    -> (InputMode -> InputMode -> Bool) -> Eq InputMode
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: InputMode -> InputMode -> Bool
    == :: InputMode -> InputMode -> Bool
    $c/= :: InputMode -> InputMode -> Bool
    /= :: 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
    $cshowsPrec :: Int -> Gravity -> ShowS
    showsPrec :: Int -> Gravity -> ShowS
    $cshow :: Gravity -> String
    show :: Gravity -> String
    $cshowList :: [Gravity] -> ShowS
    showList :: [Gravity] -> ShowS
    Show, Gravity -> Gravity -> Bool
    (Gravity -> Gravity -> Bool)
    -> (Gravity -> Gravity -> Bool) -> Eq Gravity
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Gravity -> Gravity -> Bool
    == :: Gravity -> Gravity -> Bool
    $c/= :: Gravity -> Gravity -> Bool
    /= :: 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
    $cshowsPrec :: Int -> GrabStatus -> ShowS
    showsPrec :: Int -> GrabStatus -> ShowS
    $cshow :: GrabStatus -> String
    show :: GrabStatus -> String
    $cshowList :: [GrabStatus] -> ShowS
    showList :: [GrabStatus] -> ShowS
    Show, GrabStatus -> GrabStatus -> Bool
    (GrabStatus -> GrabStatus -> Bool)
    -> (GrabStatus -> GrabStatus -> Bool) -> Eq GrabStatus
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: GrabStatus -> GrabStatus -> Bool
    == :: GrabStatus -> GrabStatus -> Bool
    $c/= :: GrabStatus -> GrabStatus -> Bool
    /= :: 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
    $cshowsPrec :: Int -> GrabOwnership -> ShowS
    showsPrec :: Int -> GrabOwnership -> ShowS
    $cshow :: GrabOwnership -> String
    show :: GrabOwnership -> String
    $cshowList :: [GrabOwnership] -> ShowS
    showList :: [GrabOwnership] -> ShowS
    Show, GrabOwnership -> GrabOwnership -> Bool
    (GrabOwnership -> GrabOwnership -> Bool)
    -> (GrabOwnership -> GrabOwnership -> Bool) -> Eq GrabOwnership
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: GrabOwnership -> GrabOwnership -> Bool
    == :: GrabOwnership -> GrabOwnership -> Bool
    $c/= :: GrabOwnership -> GrabOwnership -> Bool
    /= :: 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
    $cshowsPrec :: Int -> GLError -> ShowS
    showsPrec :: Int -> GLError -> ShowS
    $cshow :: GLError -> String
    show :: GLError -> String
    $cshowList :: [GLError] -> ShowS
    showList :: [GLError] -> ShowS
    Show, GLError -> GLError -> Bool
    (GLError -> GLError -> Bool)
    -> (GLError -> GLError -> Bool) -> Eq GLError
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: GLError -> GLError -> Bool
    == :: GLError -> GLError -> Bool
    $c/= :: GLError -> GLError -> Bool
    /= :: 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 :: forall a. 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 :: forall a. (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
    $cshowsPrec :: Int -> FullscreenMode -> ShowS
    showsPrec :: Int -> FullscreenMode -> ShowS
    $cshow :: FullscreenMode -> String
    show :: FullscreenMode -> String
    $cshowList :: [FullscreenMode] -> ShowS
    showList :: [FullscreenMode] -> ShowS
    Show, FullscreenMode -> FullscreenMode -> Bool
    (FullscreenMode -> FullscreenMode -> Bool)
    -> (FullscreenMode -> FullscreenMode -> Bool) -> Eq FullscreenMode
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: FullscreenMode -> FullscreenMode -> Bool
    == :: FullscreenMode -> FullscreenMode -> Bool
    $c/= :: FullscreenMode -> FullscreenMode -> Bool
    /= :: 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
    $cshowsPrec :: Int -> FilterReturn -> ShowS
    showsPrec :: Int -> FilterReturn -> ShowS
    $cshow :: FilterReturn -> String
    show :: FilterReturn -> String
    $cshowList :: [FilterReturn] -> ShowS
    showList :: [FilterReturn] -> ShowS
    Show, FilterReturn -> FilterReturn -> Bool
    (FilterReturn -> FilterReturn -> Bool)
    -> (FilterReturn -> FilterReturn -> Bool) -> Eq FilterReturn
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: FilterReturn -> FilterReturn -> Bool
    == :: FilterReturn -> FilterReturn -> Bool
    $c/= :: FilterReturn -> FilterReturn -> Bool
    /= :: 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
    $cshowsPrec :: Int -> EventType -> ShowS
    showsPrec :: Int -> EventType -> ShowS
    $cshow :: EventType -> String
    show :: EventType -> String
    $cshowList :: [EventType] -> ShowS
    showList :: [EventType] -> ShowS
    Show, EventType -> EventType -> Bool
    (EventType -> EventType -> Bool)
    -> (EventType -> EventType -> Bool) -> Eq EventType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: EventType -> EventType -> Bool
    == :: EventType -> EventType -> Bool
    $c/= :: EventType -> EventType -> Bool
    /= :: 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
    $cshowsPrec :: Int -> DragProtocol -> ShowS
    showsPrec :: Int -> DragProtocol -> ShowS
    $cshow :: DragProtocol -> String
    show :: DragProtocol -> String
    $cshowList :: [DragProtocol] -> ShowS
    showList :: [DragProtocol] -> ShowS
    Show, DragProtocol -> DragProtocol -> Bool
    (DragProtocol -> DragProtocol -> Bool)
    -> (DragProtocol -> DragProtocol -> Bool) -> Eq DragProtocol
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: DragProtocol -> DragProtocol -> Bool
    == :: DragProtocol -> DragProtocol -> Bool
    $c/= :: DragProtocol -> DragProtocol -> Bool
    /= :: 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
    $cshowsPrec :: Int -> DragCancelReason -> ShowS
    showsPrec :: Int -> DragCancelReason -> ShowS
    $cshow :: DragCancelReason -> String
    show :: DragCancelReason -> String
    $cshowList :: [DragCancelReason] -> ShowS
    showList :: [DragCancelReason] -> ShowS
    Show, DragCancelReason -> DragCancelReason -> Bool
    (DragCancelReason -> DragCancelReason -> Bool)
    -> (DragCancelReason -> DragCancelReason -> Bool)
    -> Eq DragCancelReason
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: DragCancelReason -> DragCancelReason -> Bool
    == :: DragCancelReason -> DragCancelReason -> Bool
    $c/= :: DragCancelReason -> DragCancelReason -> Bool
    /= :: 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
    $cshowsPrec :: Int -> DeviceType -> ShowS
    showsPrec :: Int -> DeviceType -> ShowS
    $cshow :: DeviceType -> String
    show :: DeviceType -> String
    $cshowList :: [DeviceType] -> ShowS
    showList :: [DeviceType] -> ShowS
    Show, DeviceType -> DeviceType -> Bool
    (DeviceType -> DeviceType -> Bool)
    -> (DeviceType -> DeviceType -> Bool) -> Eq DeviceType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: DeviceType -> DeviceType -> Bool
    == :: DeviceType -> DeviceType -> Bool
    $c/= :: DeviceType -> DeviceType -> Bool
    /= :: 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
    $cshowsPrec :: Int -> DeviceToolType -> ShowS
    showsPrec :: Int -> DeviceToolType -> ShowS
    $cshow :: DeviceToolType -> String
    show :: DeviceToolType -> String
    $cshowList :: [DeviceToolType] -> ShowS
    showList :: [DeviceToolType] -> ShowS
    Show, DeviceToolType -> DeviceToolType -> Bool
    (DeviceToolType -> DeviceToolType -> Bool)
    -> (DeviceToolType -> DeviceToolType -> Bool) -> Eq DeviceToolType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: DeviceToolType -> DeviceToolType -> Bool
    == :: DeviceToolType -> DeviceToolType -> Bool
    $c/= :: DeviceToolType -> DeviceToolType -> Bool
    /= :: 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
    $cshowsPrec :: Int -> DevicePadFeature -> ShowS
    showsPrec :: Int -> DevicePadFeature -> ShowS
    $cshow :: DevicePadFeature -> String
    show :: DevicePadFeature -> String
    $cshowList :: [DevicePadFeature] -> ShowS
    showList :: [DevicePadFeature] -> ShowS
    Show, DevicePadFeature -> DevicePadFeature -> Bool
    (DevicePadFeature -> DevicePadFeature -> Bool)
    -> (DevicePadFeature -> DevicePadFeature -> Bool)
    -> Eq DevicePadFeature
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: DevicePadFeature -> DevicePadFeature -> Bool
    == :: DevicePadFeature -> DevicePadFeature -> Bool
    $c/= :: DevicePadFeature -> DevicePadFeature -> Bool
    /= :: 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
    $cshowsPrec :: Int -> CursorType -> ShowS
    showsPrec :: Int -> CursorType -> ShowS
    $cshow :: CursorType -> String
    show :: CursorType -> String
    $cshowList :: [CursorType] -> ShowS
    showList :: [CursorType] -> ShowS
    Show, CursorType -> CursorType -> Bool
    (CursorType -> CursorType -> Bool)
    -> (CursorType -> CursorType -> Bool) -> Eq CursorType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: CursorType -> CursorType -> Bool
    == :: CursorType -> CursorType -> Bool
    $c/= :: CursorType -> CursorType -> Bool
    /= :: 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
    $cshowsPrec :: Int -> CrossingMode -> ShowS
    showsPrec :: Int -> CrossingMode -> ShowS
    $cshow :: CrossingMode -> String
    show :: CrossingMode -> String
    $cshowList :: [CrossingMode] -> ShowS
    showList :: [CrossingMode] -> ShowS
    Show, CrossingMode -> CrossingMode -> Bool
    (CrossingMode -> CrossingMode -> Bool)
    -> (CrossingMode -> CrossingMode -> Bool) -> Eq CrossingMode
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: CrossingMode -> CrossingMode -> Bool
    == :: CrossingMode -> CrossingMode -> Bool
    $c/= :: CrossingMode -> CrossingMode -> Bool
    /= :: 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
    $cshowsPrec :: Int -> ByteOrder -> ShowS
    showsPrec :: Int -> ByteOrder -> ShowS
    $cshow :: ByteOrder -> String
    show :: ByteOrder -> String
    $cshowList :: [ByteOrder] -> ShowS
    showList :: [ByteOrder] -> ShowS
    Show, ByteOrder -> ByteOrder -> Bool
    (ByteOrder -> ByteOrder -> Bool)
    -> (ByteOrder -> ByteOrder -> Bool) -> Eq ByteOrder
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ByteOrder -> ByteOrder -> Bool
    == :: ByteOrder -> ByteOrder -> Bool
    $c/= :: ByteOrder -> ByteOrder -> Bool
    /= :: 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
    $cshowsPrec :: Int -> AxisUse -> ShowS
    showsPrec :: Int -> AxisUse -> ShowS
    $cshow :: AxisUse -> String
    show :: AxisUse -> String
    $cshowList :: [AxisUse] -> ShowS
    showList :: [AxisUse] -> ShowS
    Show, AxisUse -> AxisUse -> Bool
    (AxisUse -> AxisUse -> Bool)
    -> (AxisUse -> AxisUse -> Bool) -> Eq AxisUse
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: AxisUse -> AxisUse -> Bool
    == :: AxisUse -> AxisUse -> Bool
    $c/= :: AxisUse -> AxisUse -> Bool
    /= :: 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