    {- |
    Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
    License    : LGPL-2.1
    Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
    -}

    #define ENABLE_OVERLOADING \
           (!defined(__HADDOCK_VERSION__))

    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.ManagedPtr as B.ManagedPtr
    import qualified Data.GI.Base.GError as B.GError
    import qualified Data.GI.Base.GVariant as B.GVariant
    import qualified Data.GI.Base.GValue as B.GValue
    import qualified Data.GI.Base.GParamSpec as B.GParamSpec
    import qualified Data.GI.Base.CallStack as B.CallStack
    import qualified Data.Text as T
    import qualified Data.ByteString.Char8 as B
    import qualified Data.Map as Map
    import qualified Foreign.Ptr as FP

    -- 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 (Show, Eq)

    instance P.Enum WindowWindowClass where
        fromEnum WindowWindowClassInputOutput = 0
        fromEnum WindowWindowClassInputOnly = 1
        fromEnum (AnotherWindowWindowClass k) = k

        toEnum 0 = WindowWindowClassInputOutput
        toEnum 1 = WindowWindowClassInputOnly
        toEnum k = AnotherWindowWindowClass k

    instance P.Ord WindowWindowClass where
        compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

    foreign import ccall "gdk_window_window_class_get_type" c_gdk_window_window_class_get_type ::
        IO GType

    instance BoxedEnum WindowWindowClass where
        boxedEnumType _ = c_gdk_window_window_class_get_type

    -- 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 (Show, Eq)

    instance P.Enum WindowTypeHint where
        fromEnum WindowTypeHintNormal = 0
        fromEnum WindowTypeHintDialog = 1
        fromEnum WindowTypeHintMenu = 2
        fromEnum WindowTypeHintToolbar = 3
        fromEnum WindowTypeHintSplashscreen = 4
        fromEnum WindowTypeHintUtility = 5
        fromEnum WindowTypeHintDock = 6
        fromEnum WindowTypeHintDesktop = 7
        fromEnum WindowTypeHintDropdownMenu = 8
        fromEnum WindowTypeHintPopupMenu = 9
        fromEnum WindowTypeHintTooltip = 10
        fromEnum WindowTypeHintNotification = 11
        fromEnum WindowTypeHintCombo = 12
        fromEnum WindowTypeHintDnd = 13
        fromEnum (AnotherWindowTypeHint k) = k

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

    instance P.Ord WindowTypeHint where
        compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

    foreign import ccall "gdk_window_type_hint_get_type" c_gdk_window_type_hint_get_type ::
        IO GType

    instance BoxedEnum WindowTypeHint where
        boxedEnumType _ = c_gdk_window_type_hint_get_type

    -- 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 (Show, Eq)

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

        toEnum 0 = WindowTypeRoot
        toEnum 1 = WindowTypeToplevel
        toEnum 2 = WindowTypeChild
        toEnum 3 = WindowTypeTemp
        toEnum 4 = WindowTypeForeign
        toEnum 5 = WindowTypeOffscreen
        toEnum 6 = WindowTypeSubsurface
        toEnum k = AnotherWindowType k

    instance P.Ord WindowType where
        compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

    foreign import ccall "gdk_window_type_get_type" c_gdk_window_type_get_type ::
        IO GType

    instance BoxedEnum WindowType where
        boxedEnumType _ = c_gdk_window_type_get_type

    -- 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 (Show, Eq)

    instance P.Enum WindowEdge where
        fromEnum WindowEdgeNorthWest = 0
        fromEnum WindowEdgeNorth = 1
        fromEnum WindowEdgeNorthEast = 2
        fromEnum WindowEdgeWest = 3
        fromEnum WindowEdgeEast = 4
        fromEnum WindowEdgeSouthWest = 5
        fromEnum WindowEdgeSouth = 6
        fromEnum WindowEdgeSouthEast = 7
        fromEnum (AnotherWindowEdge k) = k

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

    instance P.Ord WindowEdge where
        compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

    foreign import ccall "gdk_window_edge_get_type" c_gdk_window_edge_get_type ::
        IO GType

    instance BoxedEnum WindowEdge where
        boxedEnumType _ = c_gdk_window_edge_get_type

    -- 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 (Show, Eq)

    instance P.Enum VisualType where
        fromEnum VisualTypeStaticGray = 0
        fromEnum VisualTypeGrayscale = 1
        fromEnum VisualTypeStaticColor = 2
        fromEnum VisualTypePseudoColor = 3
        fromEnum VisualTypeTrueColor = 4
        fromEnum VisualTypeDirectColor = 5
        fromEnum (AnotherVisualType k) = k

        toEnum 0 = VisualTypeStaticGray
        toEnum 1 = VisualTypeGrayscale
        toEnum 2 = VisualTypeStaticColor
        toEnum 3 = VisualTypePseudoColor
        toEnum 4 = VisualTypeTrueColor
        toEnum 5 = VisualTypeDirectColor
        toEnum k = AnotherVisualType k

    instance P.Ord VisualType where
        compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

    foreign import ccall "gdk_visual_type_get_type" c_gdk_visual_type_get_type ::
        IO GType

    instance BoxedEnum VisualType where
        boxedEnumType _ = c_gdk_visual_type_get_type

    -- Enum VisibilityState
    {- |
    Specifies the visiblity status of a window for a '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 (Show, Eq)

    instance P.Enum VisibilityState where
        fromEnum VisibilityStateUnobscured = 0
        fromEnum VisibilityStatePartial = 1
        fromEnum VisibilityStateFullyObscured = 2
        fromEnum (AnotherVisibilityState k) = k

        toEnum 0 = VisibilityStateUnobscured
        toEnum 1 = VisibilityStatePartial
        toEnum 2 = VisibilityStateFullyObscured
        toEnum k = AnotherVisibilityState k

    instance P.Ord VisibilityState where
        compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

    foreign import ccall "gdk_visibility_state_get_type" c_gdk_visibility_state_get_type ::
        IO GType

    instance BoxedEnum VisibilityState where
        boxedEnumType _ = c_gdk_visibility_state_get_type

    -- 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 'GI.Gdk.Structs.EventTouchpadSwipe.EventTouchpadSwipe' and '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 (Show, Eq)

    instance P.Enum TouchpadGesturePhase where
        fromEnum TouchpadGesturePhaseBegin = 0
        fromEnum TouchpadGesturePhaseUpdate = 1
        fromEnum TouchpadGesturePhaseEnd = 2
        fromEnum TouchpadGesturePhaseCancel = 3
        fromEnum (AnotherTouchpadGesturePhase k) = k

        toEnum 0 = TouchpadGesturePhaseBegin
        toEnum 1 = TouchpadGesturePhaseUpdate
        toEnum 2 = TouchpadGesturePhaseEnd
        toEnum 3 = TouchpadGesturePhaseCancel
        toEnum k = AnotherTouchpadGesturePhase k

    instance P.Ord TouchpadGesturePhase where
        compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

    foreign import ccall "gdk_touchpad_gesture_phase_get_type" c_gdk_touchpad_gesture_phase_get_type ::
        IO GType

    instance BoxedEnum TouchpadGesturePhase where
        boxedEnumType _ = c_gdk_touchpad_gesture_phase_get_type

    -- 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 (Show, Eq)

    instance P.Enum SubpixelLayout where
        fromEnum SubpixelLayoutUnknown = 0
        fromEnum SubpixelLayoutNone = 1
        fromEnum SubpixelLayoutHorizontalRgb = 2
        fromEnum SubpixelLayoutHorizontalBgr = 3
        fromEnum SubpixelLayoutVerticalRgb = 4
        fromEnum SubpixelLayoutVerticalBgr = 5
        fromEnum (AnotherSubpixelLayout k) = k

        toEnum 0 = SubpixelLayoutUnknown
        toEnum 1 = SubpixelLayoutNone
        toEnum 2 = SubpixelLayoutHorizontalRgb
        toEnum 3 = SubpixelLayoutHorizontalBgr
        toEnum 4 = SubpixelLayoutVerticalRgb
        toEnum 5 = SubpixelLayoutVerticalBgr
        toEnum k = AnotherSubpixelLayout k

    instance P.Ord SubpixelLayout where
        compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

    foreign import ccall "gdk_subpixel_layout_get_type" c_gdk_subpixel_layout_get_type ::
        IO GType

    instance BoxedEnum SubpixelLayout where
        boxedEnumType _ = c_gdk_subpixel_layout_get_type

    -- 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 (Show, Eq)

    instance P.Enum Status where
        fromEnum StatusOk = 0
        fromEnum StatusError = -1
        fromEnum StatusErrorParam = -2
        fromEnum StatusErrorFile = -3
        fromEnum StatusErrorMem = -4
        fromEnum (AnotherStatus k) = k

        toEnum 0 = StatusOk
        toEnum -1 = StatusError
        toEnum -2 = StatusErrorParam
        toEnum -3 = StatusErrorFile
        toEnum -4 = StatusErrorMem
        toEnum k = AnotherStatus k

    instance P.Ord Status where
        compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

    foreign import ccall "gdk_status_get_type" c_gdk_status_get_type ::
        IO GType

    instance BoxedEnum Status where
        boxedEnumType _ = c_gdk_status_get_type

    -- Enum SettingAction
    {- |
    Specifies the kind of modification applied to a setting in a
    '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 (Show, Eq)

    instance P.Enum SettingAction where
        fromEnum SettingActionNew = 0
        fromEnum SettingActionChanged = 1
        fromEnum SettingActionDeleted = 2
        fromEnum (AnotherSettingAction k) = k

        toEnum 0 = SettingActionNew
        toEnum 1 = SettingActionChanged
        toEnum 2 = SettingActionDeleted
        toEnum k = AnotherSettingAction k

    instance P.Ord SettingAction where
        compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

    foreign import ccall "gdk_setting_action_get_type" c_gdk_setting_action_get_type ::
        IO GType

    instance BoxedEnum SettingAction where
        boxedEnumType _ = c_gdk_setting_action_get_type

    -- Enum ScrollDirection
    {- |
    Specifies the direction for '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 'GI.Gdk.Structs.EventScroll.EventScroll'. See 'GI.Gdk.Unions.Event.eventGetScrollDeltas'. Since: 3.4
        -}
        | AnotherScrollDirection Int
        -- ^ Catch-all for unknown values
        deriving (Show, Eq)

    instance P.Enum ScrollDirection where
        fromEnum ScrollDirectionUp = 0
        fromEnum ScrollDirectionDown = 1
        fromEnum ScrollDirectionLeft = 2
        fromEnum ScrollDirectionRight = 3
        fromEnum ScrollDirectionSmooth = 4
        fromEnum (AnotherScrollDirection k) = k

        toEnum 0 = ScrollDirectionUp
        toEnum 1 = ScrollDirectionDown
        toEnum 2 = ScrollDirectionLeft
        toEnum 3 = ScrollDirectionRight
        toEnum 4 = ScrollDirectionSmooth
        toEnum k = AnotherScrollDirection k

    instance P.Ord ScrollDirection where
        compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

    foreign import ccall "gdk_scroll_direction_get_type" c_gdk_scroll_direction_get_type ::
        IO GType

    instance BoxedEnum ScrollDirection where
        boxedEnumType _ = c_gdk_scroll_direction_get_type

    -- Enum PropertyState
    {- |
    Specifies the type of a property change for a '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 (Show, Eq)

    instance P.Enum PropertyState where
        fromEnum PropertyStateNewValue = 0
        fromEnum PropertyStateDelete = 1
        fromEnum (AnotherPropertyState k) = k

        toEnum 0 = PropertyStateNewValue
        toEnum 1 = PropertyStateDelete
        toEnum k = AnotherPropertyState k

    instance P.Ord PropertyState where
        compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

    foreign import ccall "gdk_property_state_get_type" c_gdk_property_state_get_type ::
        IO GType

    instance BoxedEnum PropertyState where
        boxedEnumType _ = c_gdk_property_state_get_type

    -- 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 (Show, Eq)

    instance P.Enum PropMode where
        fromEnum PropModeReplace = 0
        fromEnum PropModePrepend = 1
        fromEnum PropModeAppend = 2
        fromEnum (AnotherPropMode k) = k

        toEnum 0 = PropModeReplace
        toEnum 1 = PropModePrepend
        toEnum 2 = PropModeAppend
        toEnum k = AnotherPropMode k

    instance P.Ord PropMode where
        compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

    foreign import ccall "gdk_prop_mode_get_type" c_gdk_prop_mode_get_type ::
        IO GType

    instance BoxedEnum PropMode where
        boxedEnumType _ = c_gdk_prop_mode_get_type

    -- 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 (Show, Eq)

    instance P.Enum OwnerChange where
        fromEnum OwnerChangeNewOwner = 0
        fromEnum OwnerChangeDestroy = 1
        fromEnum OwnerChangeClose = 2
        fromEnum (AnotherOwnerChange k) = k

        toEnum 0 = OwnerChangeNewOwner
        toEnum 1 = OwnerChangeDestroy
        toEnum 2 = OwnerChangeClose
        toEnum k = AnotherOwnerChange k

    instance P.Ord OwnerChange where
        compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

    foreign import ccall "gdk_owner_change_get_type" c_gdk_owner_change_get_type ::
        IO GType

    instance BoxedEnum OwnerChange where
        boxedEnumType _ = c_gdk_owner_change_get_type

    -- Enum NotifyType
    {- |
    Specifies the kind of crossing for '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 (Show, Eq)

    instance P.Enum NotifyType where
        fromEnum NotifyTypeAncestor = 0
        fromEnum NotifyTypeVirtual = 1
        fromEnum NotifyTypeInferior = 2
        fromEnum NotifyTypeNonlinear = 3
        fromEnum NotifyTypeNonlinearVirtual = 4
        fromEnum NotifyTypeUnknown = 5
        fromEnum (AnotherNotifyType k) = k

        toEnum 0 = NotifyTypeAncestor
        toEnum 1 = NotifyTypeVirtual
        toEnum 2 = NotifyTypeInferior
        toEnum 3 = NotifyTypeNonlinear
        toEnum 4 = NotifyTypeNonlinearVirtual
        toEnum 5 = NotifyTypeUnknown
        toEnum k = AnotherNotifyType k

    instance P.Ord NotifyType where
        compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

    foreign import ccall "gdk_notify_type_get_type" c_gdk_notify_type_get_type ::
        IO GType

    instance BoxedEnum NotifyType where
        boxedEnumType _ = c_gdk_notify_type_get_type

    -- 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 (Show, Eq)

    instance P.Enum ModifierIntent where
        fromEnum ModifierIntentPrimaryAccelerator = 0
        fromEnum ModifierIntentContextMenu = 1
        fromEnum ModifierIntentExtendSelection = 2
        fromEnum ModifierIntentModifySelection = 3
        fromEnum ModifierIntentNoTextInput = 4
        fromEnum ModifierIntentShiftGroup = 5
        fromEnum ModifierIntentDefaultModMask = 6
        fromEnum (AnotherModifierIntent k) = k

        toEnum 0 = ModifierIntentPrimaryAccelerator
        toEnum 1 = ModifierIntentContextMenu
        toEnum 2 = ModifierIntentExtendSelection
        toEnum 3 = ModifierIntentModifySelection
        toEnum 4 = ModifierIntentNoTextInput
        toEnum 5 = ModifierIntentShiftGroup
        toEnum 6 = ModifierIntentDefaultModMask
        toEnum k = AnotherModifierIntent k

    instance P.Ord ModifierIntent where
        compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

    foreign import ccall "gdk_modifier_intent_get_type" c_gdk_modifier_intent_get_type ::
        IO GType

    instance BoxedEnum ModifierIntent where
        boxedEnumType _ = c_gdk_modifier_intent_get_type

    -- 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 (Show, Eq)

    instance P.Enum InputSource where
        fromEnum InputSourceMouse = 0
        fromEnum InputSourcePen = 1
        fromEnum InputSourceEraser = 2
        fromEnum InputSourceCursor = 3
        fromEnum InputSourceKeyboard = 4
        fromEnum InputSourceTouchscreen = 5
        fromEnum InputSourceTouchpad = 6
        fromEnum InputSourceTrackpoint = 7
        fromEnum InputSourceTabletPad = 8
        fromEnum (AnotherInputSource k) = k

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

    instance P.Ord InputSource where
        compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

    foreign import ccall "gdk_input_source_get_type" c_gdk_input_source_get_type ::
        IO GType

    instance BoxedEnum InputSource where
        boxedEnumType _ = c_gdk_input_source_get_type

    -- 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 (Show, Eq)

    instance P.Enum InputMode where
        fromEnum InputModeDisabled = 0
        fromEnum InputModeScreen = 1
        fromEnum InputModeWindow = 2
        fromEnum (AnotherInputMode k) = k

        toEnum 0 = InputModeDisabled
        toEnum 1 = InputModeScreen
        toEnum 2 = InputModeWindow
        toEnum k = AnotherInputMode k

    instance P.Ord InputMode where
        compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

    foreign import ccall "gdk_input_mode_get_type" c_gdk_input_mode_get_type ::
        IO GType

    instance BoxedEnum InputMode where
        boxedEnumType _ = c_gdk_input_mode_get_type

    -- 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 (Show, Eq)

    instance P.Enum Gravity where
        fromEnum GravityNorthWest = 1
        fromEnum GravityNorth = 2
        fromEnum GravityNorthEast = 3
        fromEnum GravityWest = 4
        fromEnum GravityCenter = 5
        fromEnum GravityEast = 6
        fromEnum GravitySouthWest = 7
        fromEnum GravitySouth = 8
        fromEnum GravitySouthEast = 9
        fromEnum GravityStatic = 10
        fromEnum (AnotherGravity k) = k

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

    instance P.Ord Gravity where
        compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

    foreign import ccall "gdk_gravity_get_type" c_gdk_gravity_get_type ::
        IO GType

    instance BoxedEnum Gravity where
        boxedEnumType _ = c_gdk_gravity_get_type

    -- 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 (Show, Eq)

    instance P.Enum GrabStatus where
        fromEnum GrabStatusSuccess = 0
        fromEnum GrabStatusAlreadyGrabbed = 1
        fromEnum GrabStatusInvalidTime = 2
        fromEnum GrabStatusNotViewable = 3
        fromEnum GrabStatusFrozen = 4
        fromEnum GrabStatusFailed = 5
        fromEnum (AnotherGrabStatus k) = k

        toEnum 0 = GrabStatusSuccess
        toEnum 1 = GrabStatusAlreadyGrabbed
        toEnum 2 = GrabStatusInvalidTime
        toEnum 3 = GrabStatusNotViewable
        toEnum 4 = GrabStatusFrozen
        toEnum 5 = GrabStatusFailed
        toEnum k = AnotherGrabStatus k

    instance P.Ord GrabStatus where
        compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

    foreign import ccall "gdk_grab_status_get_type" c_gdk_grab_status_get_type ::
        IO GType

    instance BoxedEnum GrabStatus where
        boxedEnumType _ = c_gdk_grab_status_get_type

    -- 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 (Show, Eq)

    instance P.Enum GrabOwnership where
        fromEnum GrabOwnershipNone = 0
        fromEnum GrabOwnershipWindow = 1
        fromEnum GrabOwnershipApplication = 2
        fromEnum (AnotherGrabOwnership k) = k

        toEnum 0 = GrabOwnershipNone
        toEnum 1 = GrabOwnershipWindow
        toEnum 2 = GrabOwnershipApplication
        toEnum k = AnotherGrabOwnership k

    instance P.Ord GrabOwnership where
        compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

    foreign import ccall "gdk_grab_ownership_get_type" c_gdk_grab_ownership_get_type ::
        IO GType

    instance BoxedEnum GrabOwnership where
        boxedEnumType _ = c_gdk_grab_ownership_get_type

    -- Enum GLError
    {- |
    Error enumeration for '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 (Show, Eq)

    instance P.Enum GLError where
        fromEnum GLErrorNotAvailable = 0
        fromEnum GLErrorUnsupportedFormat = 1
        fromEnum GLErrorUnsupportedProfile = 2
        fromEnum (AnotherGLError k) = k

        toEnum 0 = GLErrorNotAvailable
        toEnum 1 = GLErrorUnsupportedFormat
        toEnum 2 = GLErrorUnsupportedProfile
        toEnum k = AnotherGLError k

    instance P.Ord GLError where
        compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

    instance GErrorClass GLError where
        gerrorClassDomain _ = "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 = 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 = handleGErrorJustDomain

    foreign import ccall "gdk_gl_error_get_type" c_gdk_gl_error_get_type ::
        IO GType

    instance BoxedEnum GLError where
        boxedEnumType _ = c_gdk_gl_error_get_type

    -- 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 (Show, Eq)

    instance P.Enum FullscreenMode where
        fromEnum FullscreenModeCurrentMonitor = 0
        fromEnum FullscreenModeAllMonitors = 1
        fromEnum (AnotherFullscreenMode k) = k

        toEnum 0 = FullscreenModeCurrentMonitor
        toEnum 1 = FullscreenModeAllMonitors
        toEnum k = AnotherFullscreenMode k

    instance P.Ord FullscreenMode where
        compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

    foreign import ccall "gdk_fullscreen_mode_get_type" c_gdk_fullscreen_mode_get_type ::
        IO GType

    instance BoxedEnum FullscreenMode where
        boxedEnumType _ = c_gdk_fullscreen_mode_get_type

    -- Enum FilterReturn
    {- |
    Specifies the result of applying a '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 (Show, Eq)

    instance P.Enum FilterReturn where
        fromEnum FilterReturnContinue = 0
        fromEnum FilterReturnTranslate = 1
        fromEnum FilterReturnRemove = 2
        fromEnum (AnotherFilterReturn k) = k

        toEnum 0 = FilterReturnContinue
        toEnum 1 = FilterReturnTranslate
        toEnum 2 = FilterReturnRemove
        toEnum k = AnotherFilterReturn k

    instance P.Ord FilterReturn where
        compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

    foreign import ccall "gdk_filter_return_get_type" c_gdk_filter_return_get_type ::
        IO GType

    instance BoxedEnum FilterReturn where
        boxedEnumType _ = c_gdk_filter_return_get_type

    -- 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 '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 (Show, Eq)

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

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

    instance P.Ord EventType where
        compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

    foreign import ccall "gdk_event_type_get_type" c_gdk_event_type_get_type ::
        IO GType

    instance BoxedEnum EventType where
        boxedEnumType _ = c_gdk_event_type_get_type

    -- Enum DragProtocol
    {- |
    Used in '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 (Show, Eq)

    instance P.Enum DragProtocol where
        fromEnum DragProtocolNone = 0
        fromEnum DragProtocolMotif = 1
        fromEnum DragProtocolXdnd = 2
        fromEnum DragProtocolRootwin = 3
        fromEnum DragProtocolWin32Dropfiles = 4
        fromEnum DragProtocolOle2 = 5
        fromEnum DragProtocolLocal = 6
        fromEnum DragProtocolWayland = 7
        fromEnum (AnotherDragProtocol k) = k

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

    instance P.Ord DragProtocol where
        compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

    foreign import ccall "gdk_drag_protocol_get_type" c_gdk_drag_protocol_get_type ::
        IO GType

    instance BoxedEnum DragProtocol where
        boxedEnumType _ = c_gdk_drag_protocol_get_type

    -- Enum DragCancelReason
    {- |
    Used in '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 (Show, Eq)

    instance P.Enum DragCancelReason where
        fromEnum DragCancelReasonNoTarget = 0
        fromEnum DragCancelReasonUserCancelled = 1
        fromEnum DragCancelReasonError = 2
        fromEnum (AnotherDragCancelReason k) = k

        toEnum 0 = DragCancelReasonNoTarget
        toEnum 1 = DragCancelReasonUserCancelled
        toEnum 2 = DragCancelReasonError
        toEnum k = AnotherDragCancelReason k

    instance P.Ord DragCancelReason where
        compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

    foreign import ccall "gdk_drag_cancel_reason_get_type" c_gdk_drag_cancel_reason_get_type ::
        IO GType

    instance BoxedEnum DragCancelReason where
        boxedEnumType _ = c_gdk_drag_cancel_reason_get_type

    -- 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 (Show, Eq)

    instance P.Enum DeviceType where
        fromEnum DeviceTypeMaster = 0
        fromEnum DeviceTypeSlave = 1
        fromEnum DeviceTypeFloating = 2
        fromEnum (AnotherDeviceType k) = k

        toEnum 0 = DeviceTypeMaster
        toEnum 1 = DeviceTypeSlave
        toEnum 2 = DeviceTypeFloating
        toEnum k = AnotherDeviceType k

    instance P.Ord DeviceType where
        compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

    foreign import ccall "gdk_device_type_get_type" c_gdk_device_type_get_type ::
        IO GType

    instance BoxedEnum DeviceType where
        boxedEnumType _ = c_gdk_device_type_get_type

    -- 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 (Show, Eq)

    instance P.Enum DeviceToolType where
        fromEnum DeviceToolTypeUnknown = 0
        fromEnum DeviceToolTypePen = 1
        fromEnum DeviceToolTypeEraser = 2
        fromEnum DeviceToolTypeBrush = 3
        fromEnum DeviceToolTypePencil = 4
        fromEnum DeviceToolTypeAirbrush = 5
        fromEnum DeviceToolTypeMouse = 6
        fromEnum DeviceToolTypeLens = 7
        fromEnum (AnotherDeviceToolType k) = k

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

    instance P.Ord DeviceToolType where
        compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

    foreign import ccall "gdk_device_tool_type_get_type" c_gdk_device_tool_type_get_type ::
        IO GType

    instance BoxedEnum DeviceToolType where
        boxedEnumType _ = c_gdk_device_tool_type_get_type

    -- 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 (Show, Eq)

    instance P.Enum DevicePadFeature where
        fromEnum DevicePadFeatureButton = 0
        fromEnum DevicePadFeatureRing = 1
        fromEnum DevicePadFeatureStrip = 2
        fromEnum (AnotherDevicePadFeature k) = k

        toEnum 0 = DevicePadFeatureButton
        toEnum 1 = DevicePadFeatureRing
        toEnum 2 = DevicePadFeatureStrip
        toEnum k = AnotherDevicePadFeature k

    instance P.Ord DevicePadFeature where
        compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

    foreign import ccall "gdk_device_pad_feature_get_type" c_gdk_device_pad_feature_get_type ::
        IO GType

    instance BoxedEnum DevicePadFeature where
        boxedEnumType _ = c_gdk_device_pad_feature_get_type

    -- 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 (Show, Eq)

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

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

    instance P.Ord CursorType where
        compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

    foreign import ccall "gdk_cursor_type_get_type" c_gdk_cursor_type_get_type ::
        IO GType

    instance BoxedEnum CursorType where
        boxedEnumType _ = c_gdk_cursor_type_get_type

    -- Enum CrossingMode
    {- |
    Specifies the crossing mode for '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 (Show, Eq)

    instance P.Enum CrossingMode where
        fromEnum CrossingModeNormal = 0
        fromEnum CrossingModeGrab = 1
        fromEnum CrossingModeUngrab = 2
        fromEnum CrossingModeGtkGrab = 3
        fromEnum CrossingModeGtkUngrab = 4
        fromEnum CrossingModeStateChanged = 5
        fromEnum CrossingModeTouchBegin = 6
        fromEnum CrossingModeTouchEnd = 7
        fromEnum CrossingModeDeviceSwitch = 8
        fromEnum (AnotherCrossingMode k) = k

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

    instance P.Ord CrossingMode where
        compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

    foreign import ccall "gdk_crossing_mode_get_type" c_gdk_crossing_mode_get_type ::
        IO GType

    instance BoxedEnum CrossingMode where
        boxedEnumType _ = c_gdk_crossing_mode_get_type

    -- 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 (Show, Eq)

    instance P.Enum ByteOrder where
        fromEnum ByteOrderLsbFirst = 0
        fromEnum ByteOrderMsbFirst = 1
        fromEnum (AnotherByteOrder k) = k

        toEnum 0 = ByteOrderLsbFirst
        toEnum 1 = ByteOrderMsbFirst
        toEnum k = AnotherByteOrder k

    instance P.Ord ByteOrder where
        compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

    foreign import ccall "gdk_byte_order_get_type" c_gdk_byte_order_get_type ::
        IO GType

    instance BoxedEnum ByteOrder where
        boxedEnumType _ = c_gdk_byte_order_get_type

    -- 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 (Show, Eq)

    instance P.Enum AxisUse where
        fromEnum AxisUseIgnore = 0
        fromEnum AxisUseX = 1
        fromEnum AxisUseY = 2
        fromEnum AxisUsePressure = 3
        fromEnum AxisUseXtilt = 4
        fromEnum AxisUseYtilt = 5
        fromEnum AxisUseWheel = 6
        fromEnum AxisUseDistance = 7
        fromEnum AxisUseRotation = 8
        fromEnum AxisUseSlider = 9
        fromEnum AxisUseLast = 10
        fromEnum (AnotherAxisUse k) = k

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

    instance P.Ord AxisUse where
        compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

    foreign import ccall "gdk_axis_use_get_type" c_gdk_axis_use_get_type ::
        IO GType

    instance BoxedEnum AxisUse where
        boxedEnumType _ = c_gdk_axis_use_get_type