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

    #if !defined(__HADDOCK_VERSION__)
    #define ENABLE_OVERLOADING
    #endif

    module GI.Gdk.Enums
        (

     -- * Enumerations

    -- ** AxisUse #enum:AxisUse#

        AxisUse(..)                             ,

    -- ** CicpRange #enum:CicpRange#

        CicpRange(..)                           ,

    -- ** ColorChannel #enum:ColorChannel#

        ColorChannel(..)                        ,

    -- ** CrossingMode #enum:CrossingMode#

        CrossingMode(..)                        ,

    -- ** DevicePadFeature #enum:DevicePadFeature#

        DevicePadFeature(..)                    ,

    -- ** DeviceToolType #enum:DeviceToolType#

        DeviceToolType(..)                      ,

    -- ** DmabufError #enum:DmabufError#

        DmabufError(..)                         ,
        catchDmabufError                        ,
        handleDmabufError                       ,

    -- ** DragCancelReason #enum:DragCancelReason#

        DragCancelReason(..)                    ,

    -- ** EventType #enum:EventType#

        EventType(..)                           ,

    -- ** FrameResult #enum:FrameResult#

        FrameResult(..)                         ,

    -- ** FullscreenMode #enum:FullscreenMode#

        FullscreenMode(..)                      ,

    -- ** GLError #enum:GLError#

        GLError(..)                             ,
        catchGLError                            ,
        handleGLError                           ,

    -- ** Gravity #enum:Gravity#

        Gravity(..)                             ,

    -- ** InputSource #enum:InputSource#

        InputSource(..)                         ,

    -- ** KeyMatch #enum:KeyMatch#

        KeyMatch(..)                            ,

    -- ** MemoryFormat #enum:MemoryFormat#

        MemoryFormat(..)                        ,

    -- ** NotifyType #enum:NotifyType#

        NotifyType(..)                          ,

    -- ** ScrollDirection #enum:ScrollDirection#

        ScrollDirection(..)                     ,

    -- ** ScrollRelativeDirection #enum:ScrollRelativeDirection#

        ScrollRelativeDirection(..)             ,

    -- ** ScrollUnit #enum:ScrollUnit#

        ScrollUnit(..)                          ,

    -- ** SubpixelLayout #enum:SubpixelLayout#

        SubpixelLayout(..)                      ,

    -- ** SurfaceEdge #enum:SurfaceEdge#

        SurfaceEdge(..)                         ,

    -- ** TextureError #enum:TextureError#

        TextureError(..)                        ,
        catchTextureError                       ,
        handleTextureError                      ,

    -- ** TitlebarGesture #enum:TitlebarGesture#

        TitlebarGesture(..)                     ,

    -- ** TouchpadGesturePhase #enum:TouchpadGesturePhase#

        TouchpadGesturePhase(..)                ,

    -- ** VulkanError #enum:VulkanError#

        VulkanError(..)                         ,
        catchVulkanError                        ,
        handleVulkanError                       ,

        ) where

    import Data.GI.Base.ShortPrelude
    import qualified Data.GI.Base.ShortPrelude as SP
    import qualified Data.GI.Base.Overloading as O
    import qualified Prelude as P

    import qualified Data.GI.Base.Attributes as GI.Attributes
    import qualified Data.GI.Base.BasicTypes as B.Types
    import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
    import qualified Data.GI.Base.GArray as B.GArray
    import qualified Data.GI.Base.GClosure as B.GClosure
    import qualified Data.GI.Base.GError as B.GError
    import qualified Data.GI.Base.GHashTable as B.GHT
    import qualified Data.GI.Base.GVariant as B.GVariant
    import qualified Data.GI.Base.GValue as B.GValue
    import qualified Data.GI.Base.GParamSpec as B.GParamSpec
    import qualified Data.GI.Base.CallStack as B.CallStack
    import qualified Data.GI.Base.Properties as B.Properties
    import qualified Data.GI.Base.Signals as B.Signals
    import qualified Control.Monad.IO.Class as MIO
    import qualified Data.Coerce as Coerce
    import qualified Data.Text as T
    import qualified Data.Kind as DK
    import qualified Data.ByteString.Char8 as B
    import qualified Data.Map as Map
    import qualified Foreign.Ptr as FP
    import qualified GHC.OverloadedLabels as OL
    import qualified GHC.Records as R
    import qualified Data.Word as DW
    import qualified Data.Int as DI
    import qualified System.Posix.Types as SPT
    import qualified Foreign.C.Types as FCT

    -- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
    #if MIN_VERSION_base(4,18,0)

    #else

    #endif

    -- Enum VulkanError
    -- | Error enumeration for @GdkVulkanContext@.
    data VulkanError =
          VulkanErrorUnsupported
        -- ^ Vulkan is not supported on this backend or has not been
        --   compiled in.
        | VulkanErrorNotAvailable
        -- ^ Vulkan support is not available on this Surface
        | AnotherVulkanError Int
        -- ^ Catch-all for unknown values
        deriving (Int -> VulkanError -> ShowS
    [VulkanError] -> ShowS
    VulkanError -> String
    (Int -> VulkanError -> ShowS)
    -> (VulkanError -> String)
    -> ([VulkanError] -> ShowS)
    -> Show VulkanError
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> VulkanError -> ShowS
    showsPrec :: Int -> VulkanError -> ShowS
    $cshow :: VulkanError -> String
    show :: VulkanError -> String
    $cshowList :: [VulkanError] -> ShowS
    showList :: [VulkanError] -> ShowS
    Show, VulkanError -> VulkanError -> Bool
    (VulkanError -> VulkanError -> Bool)
    -> (VulkanError -> VulkanError -> Bool) -> Eq VulkanError
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: VulkanError -> VulkanError -> Bool
    == :: VulkanError -> VulkanError -> Bool
    $c/= :: VulkanError -> VulkanError -> Bool
    /= :: VulkanError -> VulkanError -> Bool
    Eq)

    instance P.Enum VulkanError where
        fromEnum :: VulkanError -> Int
    fromEnum VulkanError
    VulkanErrorUnsupported = Int
    0
        fromEnum VulkanError
    VulkanErrorNotAvailable = Int
    1
        fromEnum (AnotherVulkanError Int
    k) = Int
    k

        toEnum :: Int -> VulkanError
    toEnum Int
    0 = VulkanError
    VulkanErrorUnsupported
        toEnum Int
    1 = VulkanError
    VulkanErrorNotAvailable
        toEnum Int
    k = Int -> VulkanError
    AnotherVulkanError Int
    k

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

    instance GErrorClass VulkanError where
        gerrorClassDomain :: VulkanError -> Text
    gerrorClassDomain VulkanError
    _ = Text
    "gdk-vulkan-error-quark"

    -- | Catch exceptions of type `VulkanError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
    catchVulkanError ::
        IO a ->
        (VulkanError -> GErrorMessage -> IO a) ->
        IO a
    catchVulkanError :: forall a. IO a -> (VulkanError -> Text -> IO a) -> IO a
    catchVulkanError = IO a -> (VulkanError -> Text -> IO a) -> IO a
    forall err a.
    GErrorClass err =>
    IO a -> (err -> Text -> IO a) -> IO a
    catchGErrorJustDomain

    -- | Handle exceptions of type `VulkanError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
    handleVulkanError ::
        (VulkanError -> GErrorMessage -> IO a) ->
        IO a ->
        IO a
    handleVulkanError :: forall a. (VulkanError -> Text -> IO a) -> IO a -> IO a
    handleVulkanError = (VulkanError -> Text -> IO a) -> IO a -> IO a
    forall err a.
    GErrorClass err =>
    (err -> Text -> IO a) -> IO a -> IO a
    handleGErrorJustDomain

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

    foreign import ccall "gdk_vulkan_error_get_type" c_gdk_vulkan_error_get_type ::
        IO GType

    instance B.Types.TypedObject VulkanError where
        glibType :: IO GType
    glibType = IO GType
    c_gdk_vulkan_error_get_type

    instance B.Types.BoxedEnum VulkanError

    -- 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.
    data TouchpadGesturePhase =
          TouchpadGesturePhaseBegin
        -- ^ The gesture has begun.
        | TouchpadGesturePhaseUpdate
        -- ^ The gesture has been updated.
        | TouchpadGesturePhaseEnd
        -- ^ The gesture was finished, changes
        --   should be permanently applied.
        | TouchpadGesturePhaseCancel
        -- ^ The gesture was cancelled, all
        --   changes should be undone.
        | AnotherTouchpadGesturePhase Int
        -- ^ Catch-all for unknown values
        deriving (Int -> TouchpadGesturePhase -> ShowS
    [TouchpadGesturePhase] -> ShowS
    TouchpadGesturePhase -> String
    (Int -> TouchpadGesturePhase -> ShowS)
    -> (TouchpadGesturePhase -> String)
    -> ([TouchpadGesturePhase] -> ShowS)
    -> Show TouchpadGesturePhase
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> TouchpadGesturePhase -> ShowS
    showsPrec :: Int -> TouchpadGesturePhase -> ShowS
    $cshow :: TouchpadGesturePhase -> String
    show :: TouchpadGesturePhase -> String
    $cshowList :: [TouchpadGesturePhase] -> ShowS
    showList :: [TouchpadGesturePhase] -> ShowS
    Show, TouchpadGesturePhase -> TouchpadGesturePhase -> Bool
    (TouchpadGesturePhase -> TouchpadGesturePhase -> Bool)
    -> (TouchpadGesturePhase -> TouchpadGesturePhase -> Bool)
    -> Eq TouchpadGesturePhase
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: TouchpadGesturePhase -> TouchpadGesturePhase -> Bool
    == :: TouchpadGesturePhase -> TouchpadGesturePhase -> Bool
    $c/= :: TouchpadGesturePhase -> TouchpadGesturePhase -> Bool
    /= :: TouchpadGesturePhase -> TouchpadGesturePhase -> Bool
    Eq)

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

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

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

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

    foreign import ccall "gdk_touchpad_gesture_phase_get_type" c_gdk_touchpad_gesture_phase_get_type ::
        IO GType

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

    instance B.Types.BoxedEnum TouchpadGesturePhase

    -- Enum TitlebarGesture
    -- | The kind of title bar gesture to emit with
    -- 'GI.Gdk.Interfaces.Toplevel.toplevelTitlebarGesture'.
    --
    -- /Since: 4.4/
    data TitlebarGesture =
          TitlebarGestureDoubleClick
        -- ^ double click gesture
        | TitlebarGestureRightClick
        -- ^ right click gesture
        | TitlebarGestureMiddleClick
        -- ^ middle click gesture
        | AnotherTitlebarGesture Int
        -- ^ Catch-all for unknown values
        deriving (Int -> TitlebarGesture -> ShowS
    [TitlebarGesture] -> ShowS
    TitlebarGesture -> String
    (Int -> TitlebarGesture -> ShowS)
    -> (TitlebarGesture -> String)
    -> ([TitlebarGesture] -> ShowS)
    -> Show TitlebarGesture
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> TitlebarGesture -> ShowS
    showsPrec :: Int -> TitlebarGesture -> ShowS
    $cshow :: TitlebarGesture -> String
    show :: TitlebarGesture -> String
    $cshowList :: [TitlebarGesture] -> ShowS
    showList :: [TitlebarGesture] -> ShowS
    Show, TitlebarGesture -> TitlebarGesture -> Bool
    (TitlebarGesture -> TitlebarGesture -> Bool)
    -> (TitlebarGesture -> TitlebarGesture -> Bool)
    -> Eq TitlebarGesture
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: TitlebarGesture -> TitlebarGesture -> Bool
    == :: TitlebarGesture -> TitlebarGesture -> Bool
    $c/= :: TitlebarGesture -> TitlebarGesture -> Bool
    /= :: TitlebarGesture -> TitlebarGesture -> Bool
    Eq)

    instance P.Enum TitlebarGesture where
        fromEnum :: TitlebarGesture -> Int
    fromEnum TitlebarGesture
    TitlebarGestureDoubleClick = Int
    1
        fromEnum TitlebarGesture
    TitlebarGestureRightClick = Int
    2
        fromEnum TitlebarGesture
    TitlebarGestureMiddleClick = Int
    3
        fromEnum (AnotherTitlebarGesture Int
    k) = Int
    k

        toEnum :: Int -> TitlebarGesture
    toEnum Int
    1 = TitlebarGesture
    TitlebarGestureDoubleClick
        toEnum Int
    2 = TitlebarGesture
    TitlebarGestureRightClick
        toEnum Int
    3 = TitlebarGesture
    TitlebarGestureMiddleClick
        toEnum Int
    k = Int -> TitlebarGesture
    AnotherTitlebarGesture Int
    k

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

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

    foreign import ccall "gdk_titlebar_gesture_get_type" c_gdk_titlebar_gesture_get_type ::
        IO GType

    instance B.Types.TypedObject TitlebarGesture where
        glibType :: IO GType
    glibType = IO GType
    c_gdk_titlebar_gesture_get_type

    instance B.Types.BoxedEnum TitlebarGesture

    -- Enum TextureError
    -- | Possible errors that can be returned by @GdkTexture@ constructors.
    --
    -- /Since: 4.6/
    data TextureError =
          TextureErrorTooLarge
        -- ^ Not enough memory to handle this image
        | TextureErrorCorruptImage
        -- ^ The image data appears corrupted
        | TextureErrorUnsupportedContent
        -- ^ The image contains features
        --   that cannot be loaded
        | TextureErrorUnsupportedFormat
        -- ^ The image format is not supported
        | AnotherTextureError Int
        -- ^ Catch-all for unknown values
        deriving (Int -> TextureError -> ShowS
    [TextureError] -> ShowS
    TextureError -> String
    (Int -> TextureError -> ShowS)
    -> (TextureError -> String)
    -> ([TextureError] -> ShowS)
    -> Show TextureError
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> TextureError -> ShowS
    showsPrec :: Int -> TextureError -> ShowS
    $cshow :: TextureError -> String
    show :: TextureError -> String
    $cshowList :: [TextureError] -> ShowS
    showList :: [TextureError] -> ShowS
    Show, TextureError -> TextureError -> Bool
    (TextureError -> TextureError -> Bool)
    -> (TextureError -> TextureError -> Bool) -> Eq TextureError
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: TextureError -> TextureError -> Bool
    == :: TextureError -> TextureError -> Bool
    $c/= :: TextureError -> TextureError -> Bool
    /= :: TextureError -> TextureError -> Bool
    Eq)

    instance P.Enum TextureError where
        fromEnum :: TextureError -> Int
    fromEnum TextureError
    TextureErrorTooLarge = Int
    0
        fromEnum TextureError
    TextureErrorCorruptImage = Int
    1
        fromEnum TextureError
    TextureErrorUnsupportedContent = Int
    2
        fromEnum TextureError
    TextureErrorUnsupportedFormat = Int
    3
        fromEnum (AnotherTextureError Int
    k) = Int
    k

        toEnum :: Int -> TextureError
    toEnum Int
    0 = TextureError
    TextureErrorTooLarge
        toEnum Int
    1 = TextureError
    TextureErrorCorruptImage
        toEnum Int
    2 = TextureError
    TextureErrorUnsupportedContent
        toEnum Int
    3 = TextureError
    TextureErrorUnsupportedFormat
        toEnum Int
    k = Int -> TextureError
    AnotherTextureError Int
    k

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

    instance GErrorClass TextureError where
        gerrorClassDomain :: TextureError -> Text
    gerrorClassDomain TextureError
    _ = Text
    "gdk-texture-error-quark"

    -- | Catch exceptions of type `TextureError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
    catchTextureError ::
        IO a ->
        (TextureError -> GErrorMessage -> IO a) ->
        IO a
    catchTextureError :: forall a. IO a -> (TextureError -> Text -> IO a) -> IO a
    catchTextureError = IO a -> (TextureError -> Text -> IO a) -> IO a
    forall err a.
    GErrorClass err =>
    IO a -> (err -> Text -> IO a) -> IO a
    catchGErrorJustDomain

    -- | Handle exceptions of type `TextureError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
    handleTextureError ::
        (TextureError -> GErrorMessage -> IO a) ->
        IO a ->
        IO a
    handleTextureError :: forall a. (TextureError -> Text -> IO a) -> IO a -> IO a
    handleTextureError = (TextureError -> Text -> IO a) -> IO a -> IO a
    forall err a.
    GErrorClass err =>
    (err -> Text -> IO a) -> IO a -> IO a
    handleGErrorJustDomain

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

    foreign import ccall "gdk_texture_error_get_type" c_gdk_texture_error_get_type ::
        IO GType

    instance B.Types.TypedObject TextureError where
        glibType :: IO GType
    glibType = IO GType
    c_gdk_texture_error_get_type

    instance B.Types.BoxedEnum TextureError

    -- Enum SurfaceEdge
    -- | Determines a surface edge or corner.
    data SurfaceEdge =
          SurfaceEdgeNorthWest
        -- ^ the top left corner.
        | SurfaceEdgeNorth
        -- ^ the top edge.
        | SurfaceEdgeNorthEast
        -- ^ the top right corner.
        | SurfaceEdgeWest
        -- ^ the left edge.
        | SurfaceEdgeEast
        -- ^ the right edge.
        | SurfaceEdgeSouthWest
        -- ^ the lower left corner.
        | SurfaceEdgeSouth
        -- ^ the lower edge.
        | SurfaceEdgeSouthEast
        -- ^ the lower right corner.
        | AnotherSurfaceEdge Int
        -- ^ Catch-all for unknown values
        deriving (Int -> SurfaceEdge -> ShowS
    [SurfaceEdge] -> ShowS
    SurfaceEdge -> String
    (Int -> SurfaceEdge -> ShowS)
    -> (SurfaceEdge -> String)
    -> ([SurfaceEdge] -> ShowS)
    -> Show SurfaceEdge
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> SurfaceEdge -> ShowS
    showsPrec :: Int -> SurfaceEdge -> ShowS
    $cshow :: SurfaceEdge -> String
    show :: SurfaceEdge -> String
    $cshowList :: [SurfaceEdge] -> ShowS
    showList :: [SurfaceEdge] -> ShowS
    Show, SurfaceEdge -> SurfaceEdge -> Bool
    (SurfaceEdge -> SurfaceEdge -> Bool)
    -> (SurfaceEdge -> SurfaceEdge -> Bool) -> Eq SurfaceEdge
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: SurfaceEdge -> SurfaceEdge -> Bool
    == :: SurfaceEdge -> SurfaceEdge -> Bool
    $c/= :: SurfaceEdge -> SurfaceEdge -> Bool
    /= :: SurfaceEdge -> SurfaceEdge -> Bool
    Eq)

    instance P.Enum SurfaceEdge where
        fromEnum :: SurfaceEdge -> Int
    fromEnum SurfaceEdge
    SurfaceEdgeNorthWest = Int
    0
        fromEnum SurfaceEdge
    SurfaceEdgeNorth = Int
    1
        fromEnum SurfaceEdge
    SurfaceEdgeNorthEast = Int
    2
        fromEnum SurfaceEdge
    SurfaceEdgeWest = Int
    3
        fromEnum SurfaceEdge
    SurfaceEdgeEast = Int
    4
        fromEnum SurfaceEdge
    SurfaceEdgeSouthWest = Int
    5
        fromEnum SurfaceEdge
    SurfaceEdgeSouth = Int
    6
        fromEnum SurfaceEdge
    SurfaceEdgeSouthEast = Int
    7
        fromEnum (AnotherSurfaceEdge Int
    k) = Int
    k

        toEnum :: Int -> SurfaceEdge
    toEnum Int
    0 = SurfaceEdge
    SurfaceEdgeNorthWest
        toEnum Int
    1 = SurfaceEdge
    SurfaceEdgeNorth
        toEnum Int
    2 = SurfaceEdge
    SurfaceEdgeNorthEast
        toEnum Int
    3 = SurfaceEdge
    SurfaceEdgeWest
        toEnum Int
    4 = SurfaceEdge
    SurfaceEdgeEast
        toEnum Int
    5 = SurfaceEdge
    SurfaceEdgeSouthWest
        toEnum Int
    6 = SurfaceEdge
    SurfaceEdgeSouth
        toEnum Int
    7 = SurfaceEdge
    SurfaceEdgeSouthEast
        toEnum Int
    k = Int -> SurfaceEdge
    AnotherSurfaceEdge Int
    k

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

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

    foreign import ccall "gdk_surface_edge_get_type" c_gdk_surface_edge_get_type ::
        IO GType

    instance B.Types.TypedObject SurfaceEdge where
        glibType :: IO GType
    glibType = IO GType
    c_gdk_surface_edge_get_type

    instance B.Types.BoxedEnum SurfaceEdge

    -- Enum SubpixelLayout
    -- | This enumeration describes how the red, green and blue components
    -- of physical pixels on an output device are laid out.
    data SubpixelLayout =
          SubpixelLayoutUnknown
        -- ^ The layout is not known
        | SubpixelLayoutNone
        -- ^ Not organized in this way
        | SubpixelLayoutHorizontalRgb
        -- ^ The layout is horizontal, the order is RGB
        | SubpixelLayoutHorizontalBgr
        -- ^ The layout is horizontal, the order is BGR
        | SubpixelLayoutVerticalRgb
        -- ^ The layout is vertical, the order is RGB
        | SubpixelLayoutVerticalBgr
        -- ^ The layout is vertical, the order is BGR
        | AnotherSubpixelLayout Int
        -- ^ Catch-all for unknown values
        deriving (Int -> SubpixelLayout -> ShowS
    [SubpixelLayout] -> ShowS
    SubpixelLayout -> String
    (Int -> SubpixelLayout -> ShowS)
    -> (SubpixelLayout -> String)
    -> ([SubpixelLayout] -> ShowS)
    -> Show SubpixelLayout
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> SubpixelLayout -> ShowS
    showsPrec :: Int -> SubpixelLayout -> ShowS
    $cshow :: SubpixelLayout -> String
    show :: SubpixelLayout -> String
    $cshowList :: [SubpixelLayout] -> ShowS
    showList :: [SubpixelLayout] -> ShowS
    Show, SubpixelLayout -> SubpixelLayout -> Bool
    (SubpixelLayout -> SubpixelLayout -> Bool)
    -> (SubpixelLayout -> SubpixelLayout -> Bool) -> Eq SubpixelLayout
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: SubpixelLayout -> SubpixelLayout -> Bool
    == :: SubpixelLayout -> SubpixelLayout -> Bool
    $c/= :: SubpixelLayout -> SubpixelLayout -> Bool
    /= :: SubpixelLayout -> SubpixelLayout -> Bool
    Eq)

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

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

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

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

    foreign import ccall "gdk_subpixel_layout_get_type" c_gdk_subpixel_layout_get_type ::
        IO GType

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

    instance B.Types.BoxedEnum SubpixelLayout

    -- Enum ScrollUnit
    -- | Specifies the unit of scroll deltas.
    --
    -- When you get 'GI.Gdk.Enums.ScrollUnitWheel', a delta of 1.0 means 1 wheel detent
    -- click in the south direction, 2.0 means 2 wheel detent clicks in the south
    -- direction... This is the same logic for negative values but in the north
    -- direction.
    --
    -- If you get 'GI.Gdk.Enums.ScrollUnitSurface', are managing a scrollable view and get a
    -- value of 123, you have to scroll 123 surface logical pixels right if it\'s
    -- /@deltaX@/ or down if it\'s /@deltaY@/. This is the same logic for negative values
    -- but you have to scroll left instead of right if it\'s /@deltaX@/ and up instead
    -- of down if it\'s /@deltaY@/.
    --
    -- 1 surface logical pixel is equal to 1 real screen pixel multiplied by the
    -- final scale factor of your graphical interface (the product of the desktop
    -- scale factor and eventually a custom scale factor in your app).
    --
    -- /Since: 4.8/
    data ScrollUnit =
          ScrollUnitWheel
        -- ^ The delta is in number of wheel clicks.
        | ScrollUnitSurface
        -- ^ The delta is in surface pixels to scroll directly
        --   on screen.
        | AnotherScrollUnit Int
        -- ^ Catch-all for unknown values
        deriving (Int -> ScrollUnit -> ShowS
    [ScrollUnit] -> ShowS
    ScrollUnit -> String
    (Int -> ScrollUnit -> ShowS)
    -> (ScrollUnit -> String)
    -> ([ScrollUnit] -> ShowS)
    -> Show ScrollUnit
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ScrollUnit -> ShowS
    showsPrec :: Int -> ScrollUnit -> ShowS
    $cshow :: ScrollUnit -> String
    show :: ScrollUnit -> String
    $cshowList :: [ScrollUnit] -> ShowS
    showList :: [ScrollUnit] -> ShowS
    Show, ScrollUnit -> ScrollUnit -> Bool
    (ScrollUnit -> ScrollUnit -> Bool)
    -> (ScrollUnit -> ScrollUnit -> Bool) -> Eq ScrollUnit
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ScrollUnit -> ScrollUnit -> Bool
    == :: ScrollUnit -> ScrollUnit -> Bool
    $c/= :: ScrollUnit -> ScrollUnit -> Bool
    /= :: ScrollUnit -> ScrollUnit -> Bool
    Eq)

    instance P.Enum ScrollUnit where
        fromEnum :: ScrollUnit -> Int
    fromEnum ScrollUnit
    ScrollUnitWheel = Int
    0
        fromEnum ScrollUnit
    ScrollUnitSurface = Int
    1
        fromEnum (AnotherScrollUnit Int
    k) = Int
    k

        toEnum :: Int -> ScrollUnit
    toEnum Int
    0 = ScrollUnit
    ScrollUnitWheel
        toEnum Int
    1 = ScrollUnit
    ScrollUnitSurface
        toEnum Int
    k = Int -> ScrollUnit
    AnotherScrollUnit Int
    k

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

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

    foreign import ccall "gdk_scroll_unit_get_type" c_gdk_scroll_unit_get_type ::
        IO GType

    instance B.Types.TypedObject ScrollUnit where
        glibType :: IO GType
    glibType = IO GType
    c_gdk_scroll_unit_get_type

    instance B.Types.BoxedEnum ScrollUnit

    -- Enum ScrollRelativeDirection
    -- | Used in scroll events, to announce the direction relative
    -- to physical motion.
    --
    -- /Since: 4.20/
    data ScrollRelativeDirection =
          ScrollRelativeDirectionIdentical
        -- ^ Physical motion and event motion are the same
        | ScrollRelativeDirectionInverted
        -- ^ Physical motion is inverted relative to event motion
        | ScrollRelativeDirectionUnknown
        -- ^ Relative motion is unknown on this device or backend
        | AnotherScrollRelativeDirection Int
        -- ^ Catch-all for unknown values
        deriving (Int -> ScrollRelativeDirection -> ShowS
    [ScrollRelativeDirection] -> ShowS
    ScrollRelativeDirection -> String
    (Int -> ScrollRelativeDirection -> ShowS)
    -> (ScrollRelativeDirection -> String)
    -> ([ScrollRelativeDirection] -> ShowS)
    -> Show ScrollRelativeDirection
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ScrollRelativeDirection -> ShowS
    showsPrec :: Int -> ScrollRelativeDirection -> ShowS
    $cshow :: ScrollRelativeDirection -> String
    show :: ScrollRelativeDirection -> String
    $cshowList :: [ScrollRelativeDirection] -> ShowS
    showList :: [ScrollRelativeDirection] -> ShowS
    Show, ScrollRelativeDirection -> ScrollRelativeDirection -> Bool
    (ScrollRelativeDirection -> ScrollRelativeDirection -> Bool)
    -> (ScrollRelativeDirection -> ScrollRelativeDirection -> Bool)
    -> Eq ScrollRelativeDirection
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ScrollRelativeDirection -> ScrollRelativeDirection -> Bool
    == :: ScrollRelativeDirection -> ScrollRelativeDirection -> Bool
    $c/= :: ScrollRelativeDirection -> ScrollRelativeDirection -> Bool
    /= :: ScrollRelativeDirection -> ScrollRelativeDirection -> Bool
    Eq)

    instance P.Enum ScrollRelativeDirection where
        fromEnum :: ScrollRelativeDirection -> Int
    fromEnum ScrollRelativeDirection
    ScrollRelativeDirectionIdentical = Int
    0
        fromEnum ScrollRelativeDirection
    ScrollRelativeDirectionInverted = Int
    1
        fromEnum ScrollRelativeDirection
    ScrollRelativeDirectionUnknown = Int
    2
        fromEnum (AnotherScrollRelativeDirection Int
    k) = Int
    k

        toEnum :: Int -> ScrollRelativeDirection
    toEnum Int
    0 = ScrollRelativeDirection
    ScrollRelativeDirectionIdentical
        toEnum Int
    1 = ScrollRelativeDirection
    ScrollRelativeDirectionInverted
        toEnum Int
    2 = ScrollRelativeDirection
    ScrollRelativeDirectionUnknown
        toEnum Int
    k = Int -> ScrollRelativeDirection
    AnotherScrollRelativeDirection Int
    k

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

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

    foreign import ccall "gdk_scroll_relative_direction_get_type" c_gdk_scroll_relative_direction_get_type ::
        IO GType

    instance B.Types.TypedObject ScrollRelativeDirection where
        glibType :: IO GType
    glibType = IO GType
    c_gdk_scroll_relative_direction_get_type

    instance B.Types.BoxedEnum ScrollRelativeDirection

    -- Enum ScrollDirection
    -- | Specifies the direction for scroll events.
    data ScrollDirection =
          ScrollDirectionUp
        -- ^ the surface is scrolled up.
        | ScrollDirectionDown
        -- ^ the surface is scrolled down.
        | ScrollDirectionLeft
        -- ^ the surface is scrolled to the left.
        | ScrollDirectionRight
        -- ^ the surface is scrolled to the right.
        | ScrollDirectionSmooth
        -- ^ the scrolling is determined by the delta values
        --   in scroll events. See 'GI.Gdk.Objects.ScrollEvent.scrollEventGetDeltas'
        | AnotherScrollDirection Int
        -- ^ Catch-all for unknown values
        deriving (Int -> ScrollDirection -> ShowS
    [ScrollDirection] -> ShowS
    ScrollDirection -> String
    (Int -> ScrollDirection -> ShowS)
    -> (ScrollDirection -> String)
    -> ([ScrollDirection] -> ShowS)
    -> Show ScrollDirection
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ScrollDirection -> ShowS
    showsPrec :: Int -> ScrollDirection -> ShowS
    $cshow :: ScrollDirection -> String
    show :: ScrollDirection -> String
    $cshowList :: [ScrollDirection] -> ShowS
    showList :: [ScrollDirection] -> ShowS
    Show, ScrollDirection -> ScrollDirection -> Bool
    (ScrollDirection -> ScrollDirection -> Bool)
    -> (ScrollDirection -> ScrollDirection -> Bool)
    -> Eq ScrollDirection
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ScrollDirection -> ScrollDirection -> Bool
    == :: ScrollDirection -> ScrollDirection -> Bool
    $c/= :: ScrollDirection -> ScrollDirection -> Bool
    /= :: ScrollDirection -> ScrollDirection -> Bool
    Eq)

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

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

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

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

    foreign import ccall "gdk_scroll_direction_get_type" c_gdk_scroll_direction_get_type ::
        IO GType

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

    instance B.Types.BoxedEnum ScrollDirection

    -- Enum NotifyType
    -- | Specifies the kind of crossing for enter and leave events.
    --
    -- See the X11 protocol specification of LeaveNotify for
    -- full details of crossing event generation.
    data NotifyType =
          NotifyTypeAncestor
        -- ^ the surface is entered from an ancestor or
        --   left towards an ancestor.
        | NotifyTypeVirtual
        -- ^ the pointer moves between an ancestor and an
        --   inferior of the surface.
        | NotifyTypeInferior
        -- ^ the surface is entered from an inferior or
        --   left towards an inferior.
        | NotifyTypeNonlinear
        -- ^ the surface is entered from or left towards
        --   a surface which is neither an ancestor nor an inferior.
        | NotifyTypeNonlinearVirtual
        -- ^ the pointer moves between two surfaces
        --   which are not ancestors of each other and the surface is part of
        --   the ancestor chain between one of these surfaces and their least
        --   common ancestor.
        | NotifyTypeUnknown
        -- ^ an unknown type of enter\/leave event occurred.
        | AnotherNotifyType Int
        -- ^ Catch-all for unknown values
        deriving (Int -> NotifyType -> ShowS
    [NotifyType] -> ShowS
    NotifyType -> String
    (Int -> NotifyType -> ShowS)
    -> (NotifyType -> String)
    -> ([NotifyType] -> ShowS)
    -> Show NotifyType
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> NotifyType -> ShowS
    showsPrec :: Int -> NotifyType -> ShowS
    $cshow :: NotifyType -> String
    show :: NotifyType -> String
    $cshowList :: [NotifyType] -> ShowS
    showList :: [NotifyType] -> ShowS
    Show, NotifyType -> NotifyType -> Bool
    (NotifyType -> NotifyType -> Bool)
    -> (NotifyType -> NotifyType -> Bool) -> Eq NotifyType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: NotifyType -> NotifyType -> Bool
    == :: NotifyType -> NotifyType -> Bool
    $c/= :: NotifyType -> NotifyType -> Bool
    /= :: NotifyType -> NotifyType -> Bool
    Eq)

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

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

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

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

    foreign import ccall "gdk_notify_type_get_type" c_gdk_notify_type_get_type ::
        IO GType

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

    instance B.Types.BoxedEnum NotifyType

    -- Enum MemoryFormat
    -- | Describes formats that image data can have in memory.
    --
    -- It describes formats by listing the contents of the memory passed to it.
    -- So @GDK_MEMORY_A8R8G8B8@ will be 1 byte (8 bits) of alpha, followed by a
    -- byte each of red, green and blue. It is not endian-dependent, so
    -- @CAIRO_FORMAT_ARGB32@ is represented by different @GdkMemoryFormats@
    -- on architectures with different endiannesses.
    --
    -- = A note on naming
    --
    -- The format names are roughly modelled after
    -- <https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VkFormat VkFormat>.
    -- A name follows @GDK_MEMORY_\<CHANNELS>_\<DATA_TYPE>_\<SUBSAMPLING> \<PREMULTIPLIED>@
    -- where CHANNELS describe how the RGBA channels are layed out in memory, with an
    -- X denoting padding. DATA_TYPE is unsigned normalized integer if not present, or
    -- otherwise FLOAT. The optional SUBSAMPLING defines the subsampling method used.
    -- The optional ENDIAN term describes the endianness if it is not
    -- host-endian. Finally, an optional PREMULTIPLIED term indicates that the color
    -- channels are premultiplied with the alpha value, if it is omitted, the data is
    -- not premultiplied or there is no alpha channel.
    --
    -- The CHANNELS are given as a list of planes seperated by underscores where
    -- each plane is split into multiple elements describing one or more bytes of memory.
    -- Each element is given as the list of channels folowed by the amount of bits taken
    -- up.
    --
    -- So the fictional format @RGB565_A8_PREMULTIPLIED@ would describe a format with 2
    -- planes where the first plane is an unsigned 16 bit integer containing the RGB
    -- channels with 5, 6, and 5 bits respectively while the 2nd plane contains the
    -- alpha channel as an unisnged 8bit integer.
    data MemoryFormat =
          MemoryFormatB8g8r8a8Premultiplied
        -- ^ 4 bytes; for blue, green, red, alpha.
        --   The color values are premultiplied with the alpha value.
        | MemoryFormatA8r8g8b8Premultiplied
        -- ^ 4 bytes; for alpha, red, green, blue.
        --   The color values are premultiplied with the alpha value.
        | MemoryFormatR8g8b8a8Premultiplied
        -- ^ 4 bytes; for red, green, blue, alpha
        --   The color values are premultiplied with the alpha value.
        | MemoryFormatB8g8r8a8
        -- ^ 4 bytes; for blue, green, red, alpha.
        | MemoryFormatA8r8g8b8
        -- ^ 4 bytes; for alpha, red, green, blue.
        | MemoryFormatR8g8b8a8
        -- ^ 4 bytes; for red, green, blue, alpha.
        | MemoryFormatA8b8g8r8
        -- ^ 4 bytes; for alpha, blue, green, red.
        | MemoryFormatR8g8b8
        -- ^ 3 bytes; for red, green, blue. The data is opaque.
        | MemoryFormatB8g8r8
        -- ^ 3 bytes; for blue, green, red. The data is opaque.
        | MemoryFormatR16g16b16
        -- ^ 3 guint16 values; for red, green, blue.
        --
        -- /Since: 4.6/
        | MemoryFormatR16g16b16a16Premultiplied
        -- ^ 4 guint16 values; for red, green, blue, alpha. The color values are
        -- premultiplied with the alpha value.
        --
        -- /Since: 4.6/
        | MemoryFormatR16g16b16a16
        -- ^ 4 guint16 values; for red, green, blue, alpha.
        --
        -- /Since: 4.6/
        | MemoryFormatR16g16b16Float
        -- ^ 3 half-float values; for red, green, blue. The data is opaque.
        --
        -- /Since: 4.6/
        | MemoryFormatR16g16b16a16FloatPremultiplied
        -- ^ 4 half-float values; for red, green, blue and alpha. The color values are
        -- premultiplied with the alpha value.
        --
        -- /Since: 4.6/
        | MemoryFormatR16g16b16a16Float
        -- ^ 4 half-float values; for red, green, blue and alpha.
        --
        -- /Since: 4.6/
        | MemoryFormatR32g32b32Float
        -- ^ 3 float values; for red, green, blue.
        | MemoryFormatR32g32b32a32FloatPremultiplied
        -- ^ 4 float values; for red, green, blue and alpha. The color values are
        -- premultiplied with the alpha value.
        --
        -- /Since: 4.6/
        | MemoryFormatR32g32b32a32Float
        -- ^ 4 float values; for red, green, blue and alpha.
        --
        -- /Since: 4.6/
        | MemoryFormatG8a8Premultiplied
        -- ^ 2 bytes; for grayscale, alpha. The color values are premultiplied with the
        -- alpha value.
        --
        -- /Since: 4.12/
        | MemoryFormatG8a8
        -- ^ 2 bytes; for grayscale, alpha.
        --
        -- /Since: 4.12/
        | MemoryFormatG8
        -- ^ One byte; for grayscale. The data is opaque.
        --
        -- /Since: 4.12/
        | MemoryFormatG16a16Premultiplied
        -- ^ 2 guint16 values; for grayscale, alpha. The color values are premultiplied
        -- with the alpha value.
        --
        -- /Since: 4.12/
        | MemoryFormatG16a16
        -- ^ 2 guint16 values; for grayscale, alpha.
        --
        -- /Since: 4.12/
        | MemoryFormatG16
        -- ^ One guint16 value; for grayscale. The data is opaque.
        --
        -- /Since: 4.12/
        | MemoryFormatA8
        -- ^ One byte; for alpha.
        --
        -- /Since: 4.12/
        | MemoryFormatA16
        -- ^ One guint16 value; for alpha.
        --
        -- /Since: 4.12/
        | MemoryFormatA16Float
        -- ^ One half-float value; for alpha.
        --
        -- /Since: 4.12/
        | MemoryFormatA32Float
        -- ^ One float value; for alpha.
        --
        -- /Since: 4.12/
        | MemoryFormatA8b8g8r8Premultiplied
        -- ^ 4 bytes; for alpha, blue, green, red, The color values are premultiplied with
        -- the alpha value.
        --
        -- /Since: 4.14/
        | MemoryFormatB8g8r8x8
        -- ^ 4 bytes; for blue, green, red, unused.
        --
        -- /Since: 4.14/
        | MemoryFormatX8r8g8b8
        -- ^ 4 bytes; for unused, red, green, blue.
        --
        -- /Since: 4.14/
        | MemoryFormatR8g8b8x8
        -- ^ 4 bytes; for red, green, blue, unused.
        --
        -- /Since: 4.14/
        | MemoryFormatX8b8g8r8
        -- ^ 4 bytes; for unused, blue, green, red.
        --
        -- /Since: 4.14/
        | MemoryFormatG8B8r8420
        -- ^ Multiplane format with 2 planes.
        --
        -- The first plane contains the first channel, usually containing
        -- luma values.
        -- The second plane with interleaved chroma values, Cb followed by Cr.
        -- Subsampled in both the X and Y direction.
        --
        -- Commonly known by the fourcc \"NV12\".
        --
        -- /Since: 4.20/
        | MemoryFormatG8R8b8420
        -- ^ Multiplane format with 2 planes.
        --
        -- The first plane contains the first channel, usually containing
        -- luma values.
        -- The second plane with interleaved chroma values, Cr followed by Cb.
        -- Subsampled in both the X and Y direction.
        --
        -- Commonly known by the fourcc \"NV21\".
        --
        -- /Since: 4.20/
        | MemoryFormatG8B8r8422
        -- ^ Multiplane format with 2 planes.
        --
        -- The first plane contains the first channel, usually containing
        -- luma values.
        -- The second plane with interleaved chroma values, Cb followed by Cr.
        -- Subsampled in the X direction.
        --
        -- Commonly known by the fourcc \"NV16\".
        --
        -- /Since: 4.20/
        | MemoryFormatG8R8b8422
        -- ^ Multiplane format with 2 planes.
        --
        -- The first plane contains the first channel, usually containing
        -- luma values.
        -- The second plane with interleaved chroma values, Cr followed by Cb.
        -- Subsampled in the X direction.
        --
        -- Commonly known by the fourcc \"NV61\".
        --
        -- /Since: 4.20/
        | MemoryFormatG8B8r8444
        -- ^ Multiplane format with 2 planes.
        --
        -- The first plane contains the first channel, usually containing
        -- luma values.
        -- The second plane with interleaved chroma values, Cb followed by Cr.
        -- This format is not subsampled.
        --
        -- Commonly known by the fourcc \"NV24\".
        --
        -- /Since: 4.20/
        | MemoryFormatG8R8b8444
        -- ^ Multiplane format with 2 planes.
        --
        -- The first plane contains the first channel, usually containing
        -- luma values.
        -- The second plane with interleaved chroma values, Cr followed by Cb.
        -- This format is not subsampled.
        --
        -- Commonly known by the fourcc \"NV42\".
        --
        -- /Since: 4.20/
        | MemoryFormatG10x6B10x6r10x6420
        -- ^ Multiplane format with 2 planes.
        --
        -- Each channel is a 16 bit integer, but only the highest 10 bits are used.
        --
        -- The first plane contains the first channel, usually containing
        -- luma values.
        -- The second plane with interleaved chroma values, Cr followed by Cb.
        -- This format is not subsampled.
        --
        -- Commonly known by the fourcc \"P010\".
        --
        -- /Since: 4.20/
        | MemoryFormatG12x4B12x4r12x4420
        -- ^ Multiplane format with 2 planes.
        --
        -- Each channel is a 16 bit integer, but only the highest 10 bits are used.
        --
        -- The first plane contains the first channel, usually containing
        -- luma values.
        -- The second plane with interleaved chroma values, Cr followed by Cb.
        -- This format is not subsampled.
        --
        -- Commonly known by the fourcc \"P012\".
        --
        -- /Since: 4.20/
        | MemoryFormatG16B16r16420
        -- ^ Multiplane format with 2 planes.
        --
        -- Each channel is a 16 bit integer.
        --
        -- The first plane contains the first channel, usually containing
        -- luma values.
        -- The second plane with interleaved chroma values, Cr followed by Cb.
        -- This format is not subsampled.
        --
        -- Commonly known by the fourcc \"P016\".
        --
        -- /Since: 4.20/
        | MemoryFormatG8B8R8410
        -- ^ Multiplane format with 3 planes.
        --
        -- Each channel is a 8 bit integer.
        --
        -- The first plane usually contains the luma channel. It is mapped
        -- into the 2nd channel.
        --
        -- The second plane usually contains the first chroma chanel.
        -- Subsampled in both the X and Y direction with 4:1 ratio. It is
        -- mapped into the 3rd channel.
        --
        -- The third plane usually contains the second chroma channel.
        -- Subsampled in both the X and Y direction with 4:1 ratio. It is
        -- mapped into the 1st channel.
        --
        -- Commonly known by the fourcc \"YUV410\".
        --
        -- /Since: 4.20/
        | MemoryFormatG8R8B8410
        -- ^ Multiplane format with 3 planes.
        --
        -- Each channel is a 8 bit integer.
        --
        -- The first plane usually contains the luma channel. It is mapped
        -- into the 2nd channel.
        --
        -- The second plane usually contains the second chroma chanel.
        -- Subsampled in both the X and Y direction with 4:1 ratio. It is
        -- mapped into the 1st channel.
        --
        -- The third plane usually contains the first chroma channel.
        -- Subsampled in both the X and Y direction with 4:1 ratio. It is
        -- mapped into the 3rd channel.
        --
        -- Commonly known by the fourcc \"YVU410\".
        --
        -- /Since: 4.20/
        | MemoryFormatG8B8R8411
        -- ^ Multiplane format with 3 planes.
        --
        -- Each channel is a 8 bit integer.
        --
        -- The first plane usually contains the luma channel. It is mapped
        -- into the 2nd channel.
        --
        -- The second plane usually contains the first chroma chanel.
        -- Subsampled in the X direction with 4:1 ratio. It is
        -- mapped into the 3rd channel.
        --
        -- The third plane usually contains the second chroma channel.
        -- Subsampled in the X direction with 4:1 ratio. It is
        -- mapped into the 1st channel.
        --
        -- Commonly known by the fourcc \"YUV411\".
        --
        -- /Since: 4.20/
        | MemoryFormatG8R8B8411
        -- ^ Multiplane format with 3 planes.
        --
        -- Each channel is a 8 bit integer.
        --
        -- The first plane usually contains the luma channel. It is mapped
        -- into the 2nd channel.
        --
        -- The second plane usually contains the second chroma chanel.
        -- Subsampled in the X direction with 4:1 ratio. It is
        -- mapped into the 1st channel.
        --
        -- The third plane usually contains the first chroma channel.
        -- Subsampled in the X direction with 4:1 ratio. It is
        -- mapped into the 3rd channel.
        --
        -- Commonly known by the fourcc \"YVU411\".
        --
        -- /Since: 4.20/
        | MemoryFormatG8B8R8420
        -- ^ Multiplane format with 3 planes.
        --
        -- Each channel is a 8 bit integer.
        --
        -- The first plane usually contains the luma channel. It is mapped
        -- into the 2nd channel.
        --
        -- The second plane usually contains the first chroma chanel.
        -- Subsampled in both the X and Y direction. It is mapped into the
        -- 3rd channel.
        --
        -- The third plane usually contains the second chroma channel.
        -- Subsampled in both the X and Y direction. It is mapped into the
        -- 1st channel.
        --
        -- Commonly known by the fourcc \"YUV420\".
        --
        -- /Since: 4.20/
        | MemoryFormatG8R8B8420
        -- ^ Multiplane format with 3 planes.
        --
        -- Each channel is a 8 bit integer.
        --
        -- The first plane usually contains the luma channel. It is mapped
        -- into the 2nd channel.
        --
        -- The second plane usually contains the second chroma chanel.
        -- Subsampled in both the X and Y direction. It is mapped into the
        -- 1st channel.
        --
        -- The third plane usually contains the first chroma channel.
        -- Subsampled in both the X and Y direction. It is mapped into the
        -- 3rd channel.
        --
        -- Commonly known by the fourcc \"YVU420\".
        --
        -- /Since: 4.20/
        | MemoryFormatG8B8R8422
        -- ^ Multiplane format with 3 planes.
        --
        -- Each channel is a 8 bit integer.
        --
        -- The first plane usually contains the luma channel. It is mapped
        -- into the 2nd channel.
        --
        -- The second plane usually contains the first chroma chanel.
        -- Subsampled in the X direction. It is mapped into the 3rd channel.
        --
        -- The third plane usually contains the second chroma channel.
        -- Subsampled in the X direction. It is mapped into the 1st channel.
        --
        -- Commonly known by the fourcc \"YUV422\".
        --
        -- /Since: 4.20/
        | MemoryFormatG8R8B8422
        -- ^ Multiplane format with 3 planes.
        --
        -- Each channel is a 8 bit integer.
        --
        -- The first plane usually contains the luma channel. It is mapped
        -- into the 2nd channel.
        --
        -- The second plane usually contains the second chroma chanel.
        -- Subsampled in the X direction. It is mapped into the 1st channel.
        --
        -- The third plane usually contains the first chroma channel.
        -- Subsampled in the X direction. It is mapped into the 3rd channel.
        --
        -- Commonly known by the fourcc \"YVU422\".
        --
        -- /Since: 4.20/
        | MemoryFormatG8B8R8444
        -- ^ Multiplane format with 3 planes.
        --
        -- Each channel is a 8 bit integer.
        --
        -- The first plane usually contains the luma channel. It is mapped
        -- into the 2nd channel.
        --
        -- The second plane usually contains the first chroma chanel. It is
        -- mapped into the 3rd channel.
        --
        -- The third plane usually contains the second chroma channel. It is
        -- mapped into the 1st channel.
        --
        -- Commonly known by the fourcc \"YUV444\".
        --
        -- /Since: 4.20/
        | MemoryFormatG8R8B8444
        -- ^ Multiplane format with 3 planes.
        --
        -- Each channel is a 8 bit integer.
        --
        -- The first plane usually contains the luma channel. It is mapped
        -- into the 2nd channel.
        --
        -- The second plane usually contains the second chroma chanel.
        -- Subsampled in the X direction. It is mapped into the 1st channel.
        --
        -- The third plane usually contains the first chroma channel.
        -- Subsampled in the X direction. It is mapped into the 3rd channel.
        --
        -- Commonly known by the fourcc \"YVU444\".
        --
        -- /Since: 4.20/
        | MemoryFormatG8b8g8r8422
        -- ^ Packed format with subsampled channels.
        --
        -- Each channel is a 8 bit integer. The red and blue\/chroma channels
        -- are subsampled and interleaved with the green\/luma channel.
        --
        -- Each block contains 2 pixels, so the width must be a multiple of
        -- 2.
        --
        -- Commonly known by the fourcc \"YUYV\".
        --
        -- /Since: 4.20/
        | MemoryFormatG8r8g8b8422
        -- ^ Packed format with subsampled channels.
        --
        -- Each channel is a 8 bit integer. The red and blue\/chroma channels
        -- are subsampled and interleaved with the green\/luma channel.
        --
        -- Each block contains 2 pixels, so the width must be a multiple of
        -- 2.
        --
        -- Commonly known by the fourcc \"YVYU\".
        --
        -- /Since: 4.20/
        | MemoryFormatR8g8b8g8422
        -- ^ Packed format with subsampled channels.
        --
        -- Each channel is a 8 bit integer. The red and blue\/chroma channels
        -- are subsampled and interleaved with the green\/luma channel.
        --
        -- Each block contains 2 pixels, so the width must be a multiple of
        -- 2.
        --
        -- Commonly known by the fourcc \"VYUY\".
        --
        -- /Since: 4.20/
        | MemoryFormatB8g8r8g8422
        -- ^ Packed format with subsampled channels.
        --
        -- Each channel is a 8 bit integer. The red and blue\/chroma channels
        -- are subsampled and interleaved with the green\/luma channel.
        --
        -- Each block contains 2 pixels, so the width must be a multiple of
        -- 2.
        --
        -- Commonly known by the fourcc \"UYVY\".
        --
        -- /Since: 4.20/
        | MemoryFormatX6g10X6b10X6r10420
        -- ^ Multiplane format with 3 planes.
        --
        -- Each channel is a 16 bit integer.
        --
        -- Only the 10 lower bits are used. The remaining ones must be set to 0 by the
        -- producer.
        --
        -- The first plane usually contains the luma channel. It is mapped
        -- into the 2nd channel.
        --
        -- The second plane usually contains the first chroma chanel.
        -- Subsampled in both the X and Y direction. It is mapped into the
        -- 3rd channel.
        --
        -- The third plane usually contains the second chroma channel.
        -- Subsampled in both the X and Y direction. It is mapped into the
        -- 1st channel.
        --
        -- Commonly known by the fourcc \"S010\".
        --
        -- /Since: 4.20/
        | MemoryFormatX6g10X6b10X6r10422
        -- ^ Multiplane format with 3 planes.
        --
        -- Each channel is a 16 bit integer.
        --
        -- Only the 10 lower bits are used. The remaining ones must be set to 0 by the
        -- producer.
        --
        -- The first plane usually contains the luma channel. It is mapped
        -- into the 2nd channel.
        --
        -- The second plane usually contains the first chroma chanel.
        -- Subsampled in the X direction. It is mapped into the 3rd channel.
        --
        -- The third plane usually contains the second chroma channel.
        -- Subsampled in the X direction. It is mapped into the 1st channel.
        --
        -- Commonly known by the fourcc \"S210\".
        --
        -- /Since: 4.20/
        | MemoryFormatX6g10X6b10X6r10444
        -- ^ Multiplane format with 3 planes.
        --
        -- Each channel is a 16 bit integer.
        --
        -- Only the 10 lower bits are used. The remaining ones must be set to 0 by the
        -- producer.
        --
        -- The first plane usually contains the luma channel. It is mapped
        -- into the 2nd channel.
        --
        -- The second plane usually contains the first chroma chanel. It is
        -- mapped into the 3rd channel.
        --
        -- The third plane usually contains the second chroma channel. It is
        -- mapped into the 1st channel.
        --
        -- Commonly known by the fourcc \"S410\".
        --
        -- /Since: 4.20/
        | MemoryFormatX4g12X4b12X4r12420
        -- ^ Multiplane format with 3 planes.
        --
        -- Each channel is a 16 bit integer.
        --
        -- Only the 12 lower bits are used. The remaining ones must be set to 0 by the
        -- producer.
        --
        -- The first plane usually contains the luma channel. It is mapped
        -- into the 2nd channel.
        --
        -- The second plane usually contains the first chroma chanel.
        -- Subsampled in both the X and Y direction. It is mapped into the
        -- 3rd channel.
        --
        -- The third plane usually contains the second chroma channel.
        -- Subsampled in both the X and Y direction. It is mapped into the
        -- 1st channel.
        --
        -- Commonly known by the fourcc \"S012\".
        --
        -- /Since: 4.20/
        | MemoryFormatX4g12X4b12X4r12422
        -- ^ Multiplane format with 3 planes.
        --
        -- Each channel is a 16 bit integer.
        --
        -- Only the 12 lower bits are used. The remaining ones must be set to 0 by the
        -- producer.
        --
        -- The first plane usually contains the luma channel. It is mapped
        -- into the 2nd channel.
        --
        -- The second plane usually contains the first chroma chanel.
        -- Subsampled in the X direction. It is mapped into the 3rd channel.
        --
        -- The third plane usually contains the second chroma channel.
        -- Subsampled in the X direction. It is mapped into the 1st channel.
        --
        -- Commonly known by the fourcc \"S212\".
        --
        -- /Since: 4.20/
        | MemoryFormatX4g12X4b12X4r12444
        -- ^ Multiplane format with 3 planes.
        --
        -- Each channel is a 16 bit integer.
        --
        -- Only the 12 lower bits are used. The remaining ones must be set to 0 by the
        -- producer.
        --
        -- The first plane usually contains the luma channel. It is mapped
        -- into the 2nd channel.
        --
        -- The second plane usually contains the first chroma chanel. It is
        -- mapped into the 3rd channel.
        --
        -- The third plane usually contains the second chroma channel. It is
        -- mapped into the 1st channel.
        --
        -- Commonly known by the fourcc \"S412\".
        --
        -- /Since: 4.20/
        | MemoryFormatG16B16R16420
        -- ^ Multiplane format with 3 planes.
        --
        -- Each channel is a 16 bit integer.
        --
        -- The first plane usually contains the luma channel. It is mapped
        -- into the 2nd channel.
        --
        -- The second plane usually contains the first chroma chanel.
        -- Subsampled in both the X and Y direction. It is mapped into the
        -- 3rd channel.
        --
        -- The third plane usually contains the second chroma channel.
        -- Subsampled in both the X and Y direction. It is mapped into the
        -- 1st channel.
        --
        -- Commonly known by the fourcc \"S016\".
        --
        -- /Since: 4.20/
        | MemoryFormatG16B16R16422
        -- ^ Multiplane format with 3 planes.
        --
        -- Each channel is a 16 bit integer.
        --
        -- The first plane usually contains the luma channel. It is mapped
        -- into the 2nd channel.
        --
        -- The second plane usually contains the first chroma chanel.
        -- Subsampled in the X direction. It is mapped into the 3rd channel.
        --
        -- The third plane usually contains the second chroma channel.
        -- Subsampled in the X direction. It is mapped into the 1st channel.
        --
        -- Commonly known by the fourcc \"S216\".
        --
        -- /Since: 4.20/
        | MemoryFormatG16B16R16444
        -- ^ Multiplane format with 3 planes.
        --
        -- Each channel is a 16 bit integer.
        --
        -- The first plane usually contains the luma channel. It is mapped
        -- into the 2nd channel.
        --
        -- The second plane usually contains the first chroma chanel. It is
        -- mapped into the 3rd channel.
        --
        -- The third plane usually contains the second chroma channel. It is
        -- mapped into the 1st channel.
        --
        -- Commonly known by the fourcc \"S416\".
        --
        -- /Since: 4.20/
        | MemoryFormatArgb2101010Premultiplied
        -- ^ 4 bytes per pixel
        --
        -- Bits 31..30 contain the alpha channel, 29..20 red, 19..10 green
        -- and 9..0 blue.
        --
        -- The color values are premultiplied with the alpha value.
        --
        -- /Since: 4.24/
        | MemoryFormatArgb2101010
        -- ^ 4 bytes per pixel
        --
        -- Bits 31..30 contain the alpha channel, 29..20 red, 19..10 green
        -- and 9..0 blue.
        --
        -- /Since: 4.24/
        | MemoryFormatXrgb2101010
        -- ^ 4 bytes per pixel
        --
        -- Bits 31..30 are padding, bits 29..20 contain red, 19..10 green
        -- and 9..0 blue.
        --
        -- The format is opaque.
        --
        -- /Since: 4.24/
        | MemoryFormatAbgr2101010Premultiplied
        -- ^ 4 bytes per pixel
        --
        -- Bits 31..30 contain the alpha channel, 29..20 blue, 19..10 green
        -- and 9..0 red.
        --
        -- The color values are premultiplied with the alpha value.
        --
        -- /Since: 4.24/
        | MemoryFormatAbgr2101010
        -- ^ 4 bytes per pixel
        --
        -- Bits 31..30 contain the alpha channel, 29..20 blue, 19..10 green
        -- and 9..0 red.
        --
        -- /Since: 4.24/
        | MemoryFormatXbgr2101010
        -- ^ 4 bytes per pixel
        --
        -- Bits 31..30 are padding, bits 29..20 contain blue, 19..10 green
        -- and 9..0 red.
        --
        -- The format is opaque.
        --
        -- /Since: 4.24/
        | MemoryFormatNFormats
        -- ^ The number of formats. This value will change as
        --   more formats get added, so do not rely on its concrete integer.
        | AnotherMemoryFormat Int
        -- ^ Catch-all for unknown values
        deriving (Int -> MemoryFormat -> ShowS
    [MemoryFormat] -> ShowS
    MemoryFormat -> String
    (Int -> MemoryFormat -> ShowS)
    -> (MemoryFormat -> String)
    -> ([MemoryFormat] -> ShowS)
    -> Show MemoryFormat
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> MemoryFormat -> ShowS
    showsPrec :: Int -> MemoryFormat -> ShowS
    $cshow :: MemoryFormat -> String
    show :: MemoryFormat -> String
    $cshowList :: [MemoryFormat] -> ShowS
    showList :: [MemoryFormat] -> ShowS
    Show, MemoryFormat -> MemoryFormat -> Bool
    (MemoryFormat -> MemoryFormat -> Bool)
    -> (MemoryFormat -> MemoryFormat -> Bool) -> Eq MemoryFormat
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: MemoryFormat -> MemoryFormat -> Bool
    == :: MemoryFormat -> MemoryFormat -> Bool
    $c/= :: MemoryFormat -> MemoryFormat -> Bool
    /= :: MemoryFormat -> MemoryFormat -> Bool
    Eq)

    instance P.Enum MemoryFormat where
        fromEnum :: MemoryFormat -> Int
    fromEnum MemoryFormat
    MemoryFormatB8g8r8a8Premultiplied = Int
    0
        fromEnum MemoryFormat
    MemoryFormatA8r8g8b8Premultiplied = Int
    1
        fromEnum MemoryFormat
    MemoryFormatR8g8b8a8Premultiplied = Int
    2
        fromEnum MemoryFormat
    MemoryFormatB8g8r8a8 = Int
    3
        fromEnum MemoryFormat
    MemoryFormatA8r8g8b8 = Int
    4
        fromEnum MemoryFormat
    MemoryFormatR8g8b8a8 = Int
    5
        fromEnum MemoryFormat
    MemoryFormatA8b8g8r8 = Int
    6
        fromEnum MemoryFormat
    MemoryFormatR8g8b8 = Int
    7
        fromEnum MemoryFormat
    MemoryFormatB8g8r8 = Int
    8
        fromEnum MemoryFormat
    MemoryFormatR16g16b16 = Int
    9
        fromEnum MemoryFormat
    MemoryFormatR16g16b16a16Premultiplied = Int
    10
        fromEnum MemoryFormat
    MemoryFormatR16g16b16a16 = Int
    11
        fromEnum MemoryFormat
    MemoryFormatR16g16b16Float = Int
    12
        fromEnum MemoryFormat
    MemoryFormatR16g16b16a16FloatPremultiplied = Int
    13
        fromEnum MemoryFormat
    MemoryFormatR16g16b16a16Float = Int
    14
        fromEnum MemoryFormat
    MemoryFormatR32g32b32Float = Int
    15
        fromEnum MemoryFormat
    MemoryFormatR32g32b32a32FloatPremultiplied = Int
    16
        fromEnum MemoryFormat
    MemoryFormatR32g32b32a32Float = Int
    17
        fromEnum MemoryFormat
    MemoryFormatG8a8Premultiplied = Int
    18
        fromEnum MemoryFormat
    MemoryFormatG8a8 = Int
    19
        fromEnum MemoryFormat
    MemoryFormatG8 = Int
    20
        fromEnum MemoryFormat
    MemoryFormatG16a16Premultiplied = Int
    21
        fromEnum MemoryFormat
    MemoryFormatG16a16 = Int
    22
        fromEnum MemoryFormat
    MemoryFormatG16 = Int
    23
        fromEnum MemoryFormat
    MemoryFormatA8 = Int
    24
        fromEnum MemoryFormat
    MemoryFormatA16 = Int
    25
        fromEnum MemoryFormat
    MemoryFormatA16Float = Int
    26
        fromEnum MemoryFormat
    MemoryFormatA32Float = Int
    27
        fromEnum MemoryFormat
    MemoryFormatA8b8g8r8Premultiplied = Int
    28
        fromEnum MemoryFormat
    MemoryFormatB8g8r8x8 = Int
    29
        fromEnum MemoryFormat
    MemoryFormatX8r8g8b8 = Int
    30
        fromEnum MemoryFormat
    MemoryFormatR8g8b8x8 = Int
    31
        fromEnum MemoryFormat
    MemoryFormatX8b8g8r8 = Int
    32
        fromEnum MemoryFormat
    MemoryFormatG8B8r8420 = Int
    33
        fromEnum MemoryFormat
    MemoryFormatG8R8b8420 = Int
    34
        fromEnum MemoryFormat
    MemoryFormatG8B8r8422 = Int
    35
        fromEnum MemoryFormat
    MemoryFormatG8R8b8422 = Int
    36
        fromEnum MemoryFormat
    MemoryFormatG8B8r8444 = Int
    37
        fromEnum MemoryFormat
    MemoryFormatG8R8b8444 = Int
    38
        fromEnum MemoryFormat
    MemoryFormatG10x6B10x6r10x6420 = Int
    39
        fromEnum MemoryFormat
    MemoryFormatG12x4B12x4r12x4420 = Int
    40
        fromEnum MemoryFormat
    MemoryFormatG16B16r16420 = Int
    41
        fromEnum MemoryFormat
    MemoryFormatG8B8R8410 = Int
    42
        fromEnum MemoryFormat
    MemoryFormatG8R8B8410 = Int
    43
        fromEnum MemoryFormat
    MemoryFormatG8B8R8411 = Int
    44
        fromEnum MemoryFormat
    MemoryFormatG8R8B8411 = Int
    45
        fromEnum MemoryFormat
    MemoryFormatG8B8R8420 = Int
    46
        fromEnum MemoryFormat
    MemoryFormatG8R8B8420 = Int
    47
        fromEnum MemoryFormat
    MemoryFormatG8B8R8422 = Int
    48
        fromEnum MemoryFormat
    MemoryFormatG8R8B8422 = Int
    49
        fromEnum MemoryFormat
    MemoryFormatG8B8R8444 = Int
    50
        fromEnum MemoryFormat
    MemoryFormatG8R8B8444 = Int
    51
        fromEnum MemoryFormat
    MemoryFormatG8b8g8r8422 = Int
    52
        fromEnum MemoryFormat
    MemoryFormatG8r8g8b8422 = Int
    53
        fromEnum MemoryFormat
    MemoryFormatR8g8b8g8422 = Int
    54
        fromEnum MemoryFormat
    MemoryFormatB8g8r8g8422 = Int
    55
        fromEnum MemoryFormat
    MemoryFormatX6g10X6b10X6r10420 = Int
    56
        fromEnum MemoryFormat
    MemoryFormatX6g10X6b10X6r10422 = Int
    57
        fromEnum MemoryFormat
    MemoryFormatX6g10X6b10X6r10444 = Int
    58
        fromEnum MemoryFormat
    MemoryFormatX4g12X4b12X4r12420 = Int
    59
        fromEnum MemoryFormat
    MemoryFormatX4g12X4b12X4r12422 = Int
    60
        fromEnum MemoryFormat
    MemoryFormatX4g12X4b12X4r12444 = Int
    61
        fromEnum MemoryFormat
    MemoryFormatG16B16R16420 = Int
    62
        fromEnum MemoryFormat
    MemoryFormatG16B16R16422 = Int
    63
        fromEnum MemoryFormat
    MemoryFormatG16B16R16444 = Int
    64
        fromEnum MemoryFormat
    MemoryFormatArgb2101010Premultiplied = Int
    65
        fromEnum MemoryFormat
    MemoryFormatArgb2101010 = Int
    66
        fromEnum MemoryFormat
    MemoryFormatXrgb2101010 = Int
    67
        fromEnum MemoryFormat
    MemoryFormatAbgr2101010Premultiplied = Int
    68
        fromEnum MemoryFormat
    MemoryFormatAbgr2101010 = Int
    69
        fromEnum MemoryFormat
    MemoryFormatXbgr2101010 = Int
    70
        fromEnum MemoryFormat
    MemoryFormatNFormats = Int
    71
        fromEnum (AnotherMemoryFormat Int
    k) = Int
    k

        toEnum :: Int -> MemoryFormat
    toEnum Int
    0 = MemoryFormat
    MemoryFormatB8g8r8a8Premultiplied
        toEnum Int
    1 = MemoryFormat
    MemoryFormatA8r8g8b8Premultiplied
        toEnum Int
    2 = MemoryFormat
    MemoryFormatR8g8b8a8Premultiplied
        toEnum Int
    3 = MemoryFormat
    MemoryFormatB8g8r8a8
        toEnum Int
    4 = MemoryFormat
    MemoryFormatA8r8g8b8
        toEnum Int
    5 = MemoryFormat
    MemoryFormatR8g8b8a8
        toEnum Int
    6 = MemoryFormat
    MemoryFormatA8b8g8r8
        toEnum Int
    7 = MemoryFormat
    MemoryFormatR8g8b8
        toEnum Int
    8 = MemoryFormat
    MemoryFormatB8g8r8
        toEnum Int
    9 = MemoryFormat
    MemoryFormatR16g16b16
        toEnum Int
    10 = MemoryFormat
    MemoryFormatR16g16b16a16Premultiplied
        toEnum Int
    11 = MemoryFormat
    MemoryFormatR16g16b16a16
        toEnum Int
    12 = MemoryFormat
    MemoryFormatR16g16b16Float
        toEnum Int
    13 = MemoryFormat
    MemoryFormatR16g16b16a16FloatPremultiplied
        toEnum Int
    14 = MemoryFormat
    MemoryFormatR16g16b16a16Float
        toEnum Int
    15 = MemoryFormat
    MemoryFormatR32g32b32Float
        toEnum Int
    16 = MemoryFormat
    MemoryFormatR32g32b32a32FloatPremultiplied
        toEnum Int
    17 = MemoryFormat
    MemoryFormatR32g32b32a32Float
        toEnum Int
    18 = MemoryFormat
    MemoryFormatG8a8Premultiplied
        toEnum Int
    19 = MemoryFormat
    MemoryFormatG8a8
        toEnum Int
    20 = MemoryFormat
    MemoryFormatG8
        toEnum Int
    21 = MemoryFormat
    MemoryFormatG16a16Premultiplied
        toEnum Int
    22 = MemoryFormat
    MemoryFormatG16a16
        toEnum Int
    23 = MemoryFormat
    MemoryFormatG16
        toEnum Int
    24 = MemoryFormat
    MemoryFormatA8
        toEnum Int
    25 = MemoryFormat
    MemoryFormatA16
        toEnum Int
    26 = MemoryFormat
    MemoryFormatA16Float
        toEnum Int
    27 = MemoryFormat
    MemoryFormatA32Float
        toEnum Int
    28 = MemoryFormat
    MemoryFormatA8b8g8r8Premultiplied
        toEnum Int
    29 = MemoryFormat
    MemoryFormatB8g8r8x8
        toEnum Int
    30 = MemoryFormat
    MemoryFormatX8r8g8b8
        toEnum Int
    31 = MemoryFormat
    MemoryFormatR8g8b8x8
        toEnum Int
    32 = MemoryFormat
    MemoryFormatX8b8g8r8
        toEnum Int
    33 = MemoryFormat
    MemoryFormatG8B8r8420
        toEnum Int
    34 = MemoryFormat
    MemoryFormatG8R8b8420
        toEnum Int
    35 = MemoryFormat
    MemoryFormatG8B8r8422
        toEnum Int
    36 = MemoryFormat
    MemoryFormatG8R8b8422
        toEnum Int
    37 = MemoryFormat
    MemoryFormatG8B8r8444
        toEnum Int
    38 = MemoryFormat
    MemoryFormatG8R8b8444
        toEnum Int
    39 = MemoryFormat
    MemoryFormatG10x6B10x6r10x6420
        toEnum Int
    40 = MemoryFormat
    MemoryFormatG12x4B12x4r12x4420
        toEnum Int
    41 = MemoryFormat
    MemoryFormatG16B16r16420
        toEnum Int
    42 = MemoryFormat
    MemoryFormatG8B8R8410
        toEnum Int
    43 = MemoryFormat
    MemoryFormatG8R8B8410
        toEnum Int
    44 = MemoryFormat
    MemoryFormatG8B8R8411
        toEnum Int
    45 = MemoryFormat
    MemoryFormatG8R8B8411
        toEnum Int
    46 = MemoryFormat
    MemoryFormatG8B8R8420
        toEnum Int
    47 = MemoryFormat
    MemoryFormatG8R8B8420
        toEnum Int
    48 = MemoryFormat
    MemoryFormatG8B8R8422
        toEnum Int
    49 = MemoryFormat
    MemoryFormatG8R8B8422
        toEnum Int
    50 = MemoryFormat
    MemoryFormatG8B8R8444
        toEnum Int
    51 = MemoryFormat
    MemoryFormatG8R8B8444
        toEnum Int
    52 = MemoryFormat
    MemoryFormatG8b8g8r8422
        toEnum Int
    53 = MemoryFormat
    MemoryFormatG8r8g8b8422
        toEnum Int
    54 = MemoryFormat
    MemoryFormatR8g8b8g8422
        toEnum Int
    55 = MemoryFormat
    MemoryFormatB8g8r8g8422
        toEnum Int
    56 = MemoryFormat
    MemoryFormatX6g10X6b10X6r10420
        toEnum Int
    57 = MemoryFormat
    MemoryFormatX6g10X6b10X6r10422
        toEnum Int
    58 = MemoryFormat
    MemoryFormatX6g10X6b10X6r10444
        toEnum Int
    59 = MemoryFormat
    MemoryFormatX4g12X4b12X4r12420
        toEnum Int
    60 = MemoryFormat
    MemoryFormatX4g12X4b12X4r12422
        toEnum Int
    61 = MemoryFormat
    MemoryFormatX4g12X4b12X4r12444
        toEnum Int
    62 = MemoryFormat
    MemoryFormatG16B16R16420
        toEnum Int
    63 = MemoryFormat
    MemoryFormatG16B16R16422
        toEnum Int
    64 = MemoryFormat
    MemoryFormatG16B16R16444
        toEnum Int
    65 = MemoryFormat
    MemoryFormatArgb2101010Premultiplied
        toEnum Int
    66 = MemoryFormat
    MemoryFormatArgb2101010
        toEnum Int
    67 = MemoryFormat
    MemoryFormatXrgb2101010
        toEnum Int
    68 = MemoryFormat
    MemoryFormatAbgr2101010Premultiplied
        toEnum Int
    69 = MemoryFormat
    MemoryFormatAbgr2101010
        toEnum Int
    70 = MemoryFormat
    MemoryFormatXbgr2101010
        toEnum Int
    71 = MemoryFormat
    MemoryFormatNFormats
        toEnum Int
    k = Int -> MemoryFormat
    AnotherMemoryFormat Int
    k

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

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

    foreign import ccall "gdk_memory_format_get_type" c_gdk_memory_format_get_type ::
        IO GType

    instance B.Types.TypedObject MemoryFormat where
        glibType :: IO GType
    glibType = IO GType
    c_gdk_memory_format_get_type

    instance B.Types.BoxedEnum MemoryFormat

    -- Enum KeyMatch
    -- | Describes how well an event matches a given keyval and modifiers.
    --
    -- @GdkKeyMatch@ values are returned by 'GI.Gdk.Objects.KeyEvent.keyEventMatches'.
    data KeyMatch =
          KeyMatchNone
        -- ^ The key event does not match
        | KeyMatchPartial
        -- ^ The key event matches if keyboard state
        --   (specifically, the currently active group) is ignored
        | KeyMatchExact
        -- ^ The key event matches
        | AnotherKeyMatch Int
        -- ^ Catch-all for unknown values
        deriving (Int -> KeyMatch -> ShowS
    [KeyMatch] -> ShowS
    KeyMatch -> String
    (Int -> KeyMatch -> ShowS)
    -> (KeyMatch -> String) -> ([KeyMatch] -> ShowS) -> Show KeyMatch
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> KeyMatch -> ShowS
    showsPrec :: Int -> KeyMatch -> ShowS
    $cshow :: KeyMatch -> String
    show :: KeyMatch -> String
    $cshowList :: [KeyMatch] -> ShowS
    showList :: [KeyMatch] -> ShowS
    Show, KeyMatch -> KeyMatch -> Bool
    (KeyMatch -> KeyMatch -> Bool)
    -> (KeyMatch -> KeyMatch -> Bool) -> Eq KeyMatch
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: KeyMatch -> KeyMatch -> Bool
    == :: KeyMatch -> KeyMatch -> Bool
    $c/= :: KeyMatch -> KeyMatch -> Bool
    /= :: KeyMatch -> KeyMatch -> Bool
    Eq)

    instance P.Enum KeyMatch where
        fromEnum :: KeyMatch -> Int
    fromEnum KeyMatch
    KeyMatchNone = Int
    0
        fromEnum KeyMatch
    KeyMatchPartial = Int
    1
        fromEnum KeyMatch
    KeyMatchExact = Int
    2
        fromEnum (AnotherKeyMatch Int
    k) = Int
    k

        toEnum :: Int -> KeyMatch
    toEnum Int
    0 = KeyMatch
    KeyMatchNone
        toEnum Int
    1 = KeyMatch
    KeyMatchPartial
        toEnum Int
    2 = KeyMatch
    KeyMatchExact
        toEnum Int
    k = Int -> KeyMatch
    AnotherKeyMatch Int
    k

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

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

    foreign import ccall "gdk_key_match_get_type" c_gdk_key_match_get_type ::
        IO GType

    instance B.Types.TypedObject KeyMatch where
        glibType :: IO GType
    glibType = IO GType
    c_gdk_key_match_get_type

    instance B.Types.BoxedEnum KeyMatch

    -- 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.
        | InputSourceKeyboard
        -- ^ the device is a keyboard.
        | InputSourceTouchscreen
        -- ^ the device is a direct-input touch device, such
        --   as a touchscreen or tablet
        | InputSourceTouchpad
        -- ^ the device is an indirect touch device, such
        --   as a touchpad
        | InputSourceTrackpoint
        -- ^ the device is a trackpoint
        | InputSourceTabletPad
        -- ^ the device is a \"pad\", a collection of buttons,
        --   rings and strips found in drawing tablets
        | AnotherInputSource Int
        -- ^ Catch-all for unknown values
        deriving (Int -> InputSource -> ShowS
    [InputSource] -> ShowS
    InputSource -> String
    (Int -> InputSource -> ShowS)
    -> (InputSource -> String)
    -> ([InputSource] -> ShowS)
    -> Show InputSource
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> InputSource -> ShowS
    showsPrec :: Int -> InputSource -> ShowS
    $cshow :: InputSource -> String
    show :: InputSource -> String
    $cshowList :: [InputSource] -> ShowS
    showList :: [InputSource] -> ShowS
    Show, InputSource -> InputSource -> Bool
    (InputSource -> InputSource -> Bool)
    -> (InputSource -> InputSource -> Bool) -> Eq InputSource
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: InputSource -> InputSource -> Bool
    == :: InputSource -> InputSource -> Bool
    $c/= :: InputSource -> InputSource -> Bool
    /= :: InputSource -> InputSource -> Bool
    Eq)

    instance P.Enum InputSource where
        fromEnum :: InputSource -> Int
    fromEnum InputSource
    InputSourceMouse = Int
    0
        fromEnum InputSource
    InputSourcePen = Int
    1
        fromEnum InputSource
    InputSourceKeyboard = Int
    2
        fromEnum InputSource
    InputSourceTouchscreen = Int
    3
        fromEnum InputSource
    InputSourceTouchpad = Int
    4
        fromEnum InputSource
    InputSourceTrackpoint = Int
    5
        fromEnum InputSource
    InputSourceTabletPad = Int
    6
        fromEnum (AnotherInputSource Int
    k) = Int
    k

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

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

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

    foreign import ccall "gdk_input_source_get_type" c_gdk_input_source_get_type ::
        IO GType

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

    instance B.Types.BoxedEnum InputSource

    -- Enum Gravity
    -- | Defines the reference point of a surface and is used in @GdkPopupLayout@.
    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 surface.
        | 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
        --  surface itself, ignoring window manager decorations.
        | AnotherGravity Int
        -- ^ Catch-all for unknown values
        deriving (Int -> Gravity -> ShowS
    [Gravity] -> ShowS
    Gravity -> String
    (Int -> Gravity -> ShowS)
    -> (Gravity -> String) -> ([Gravity] -> ShowS) -> Show Gravity
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Gravity -> ShowS
    showsPrec :: Int -> Gravity -> ShowS
    $cshow :: Gravity -> String
    show :: Gravity -> String
    $cshowList :: [Gravity] -> ShowS
    showList :: [Gravity] -> ShowS
    Show, Gravity -> Gravity -> Bool
    (Gravity -> Gravity -> Bool)
    -> (Gravity -> Gravity -> Bool) -> Eq Gravity
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Gravity -> Gravity -> Bool
    == :: Gravity -> Gravity -> Bool
    $c/= :: Gravity -> Gravity -> Bool
    /= :: Gravity -> Gravity -> Bool
    Eq)

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

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

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

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

    foreign import ccall "gdk_gravity_get_type" c_gdk_gravity_get_type ::
        IO GType

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

    instance B.Types.BoxedEnum Gravity

    -- Enum GLError
    -- | Error enumeration for @GdkGLContext@.
    data GLError =
          GLErrorNotAvailable
        -- ^ OpenGL support is not available
        | GLErrorUnsupportedFormat
        -- ^ The requested visual format is not supported
        | GLErrorUnsupportedProfile
        -- ^ The requested profile is not supported
        | GLErrorCompilationFailed
        -- ^ The shader compilation failed
        | GLErrorLinkFailed
        -- ^ The shader linking failed
        | AnotherGLError Int
        -- ^ Catch-all for unknown values
        deriving (Int -> GLError -> ShowS
    [GLError] -> ShowS
    GLError -> String
    (Int -> GLError -> ShowS)
    -> (GLError -> String) -> ([GLError] -> ShowS) -> Show GLError
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> GLError -> ShowS
    showsPrec :: Int -> GLError -> ShowS
    $cshow :: GLError -> String
    show :: GLError -> String
    $cshowList :: [GLError] -> ShowS
    showList :: [GLError] -> ShowS
    Show, GLError -> GLError -> Bool
    (GLError -> GLError -> Bool)
    -> (GLError -> GLError -> Bool) -> Eq GLError
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: GLError -> GLError -> Bool
    == :: GLError -> GLError -> Bool
    $c/= :: GLError -> GLError -> Bool
    /= :: GLError -> GLError -> Bool
    Eq)

    instance P.Enum GLError where
        fromEnum :: GLError -> Int
    fromEnum GLError
    GLErrorNotAvailable = Int
    0
        fromEnum GLError
    GLErrorUnsupportedFormat = Int
    1
        fromEnum GLError
    GLErrorUnsupportedProfile = Int
    2
        fromEnum GLError
    GLErrorCompilationFailed = Int
    3
        fromEnum GLError
    GLErrorLinkFailed = Int
    4
        fromEnum (AnotherGLError Int
    k) = Int
    k

        toEnum :: Int -> GLError
    toEnum Int
    0 = GLError
    GLErrorNotAvailable
        toEnum Int
    1 = GLError
    GLErrorUnsupportedFormat
        toEnum Int
    2 = GLError
    GLErrorUnsupportedProfile
        toEnum Int
    3 = GLError
    GLErrorCompilationFailed
        toEnum Int
    4 = GLError
    GLErrorLinkFailed
        toEnum Int
    k = Int -> GLError
    AnotherGLError Int
    k

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

    instance GErrorClass GLError where
        gerrorClassDomain :: GLError -> Text
    gerrorClassDomain GLError
    _ = Text
    "gdk-gl-error-quark"

    -- | Catch exceptions of type `GLError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
    catchGLError ::
        IO a ->
        (GLError -> GErrorMessage -> IO a) ->
        IO a
    catchGLError :: forall a. IO a -> (GLError -> Text -> IO a) -> IO a
    catchGLError = IO a -> (GLError -> Text -> IO a) -> IO a
    forall err a.
    GErrorClass err =>
    IO a -> (err -> Text -> IO a) -> IO a
    catchGErrorJustDomain

    -- | Handle exceptions of type `GLError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
    handleGLError ::
        (GLError -> GErrorMessage -> IO a) ->
        IO a ->
        IO a
    handleGLError :: forall a. (GLError -> Text -> IO a) -> IO a -> IO a
    handleGLError = (GLError -> Text -> IO a) -> IO a -> IO a
    forall err a.
    GErrorClass err =>
    (err -> Text -> IO a) -> IO a -> IO a
    handleGErrorJustDomain

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

    foreign import ccall "gdk_gl_error_get_type" c_gdk_gl_error_get_type ::
        IO GType

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

    instance B.Types.BoxedEnum GLError

    -- Enum FullscreenMode
    -- | Indicates which monitor a surface should span over when in fullscreen mode.
    data FullscreenMode =
          FullscreenModeCurrentMonitor
        -- ^ Fullscreen on current monitor only.
        | FullscreenModeAllMonitors
        -- ^ Span across all monitors when fullscreen.
        | AnotherFullscreenMode Int
        -- ^ Catch-all for unknown values
        deriving (Int -> FullscreenMode -> ShowS
    [FullscreenMode] -> ShowS
    FullscreenMode -> String
    (Int -> FullscreenMode -> ShowS)
    -> (FullscreenMode -> String)
    -> ([FullscreenMode] -> ShowS)
    -> Show FullscreenMode
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> FullscreenMode -> ShowS
    showsPrec :: Int -> FullscreenMode -> ShowS
    $cshow :: FullscreenMode -> String
    show :: FullscreenMode -> String
    $cshowList :: [FullscreenMode] -> ShowS
    showList :: [FullscreenMode] -> ShowS
    Show, FullscreenMode -> FullscreenMode -> Bool
    (FullscreenMode -> FullscreenMode -> Bool)
    -> (FullscreenMode -> FullscreenMode -> Bool) -> Eq FullscreenMode
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: FullscreenMode -> FullscreenMode -> Bool
    == :: FullscreenMode -> FullscreenMode -> Bool
    $c/= :: FullscreenMode -> FullscreenMode -> Bool
    /= :: FullscreenMode -> FullscreenMode -> Bool
    Eq)

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

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

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

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

    foreign import ccall "gdk_fullscreen_mode_get_type" c_gdk_fullscreen_mode_get_type ::
        IO GType

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

    instance B.Types.BoxedEnum FullscreenMode

    -- Enum FrameResult
    -- | An enumeration describing the process of rendering a frame.
    -- Rendering a frame starts with the frame clock cycle and then follows
    -- the rendered frame (if there was one) through the display server
    -- until it appears on screen.
    --
    -- It is relevant in particular for t'GI.Gdk.Structs.FrameTimings.FrameTimings' which
    -- may still be waiting for values to be filled in.
    --
    -- /Since: 4.24/
    data FrameResult =
          FrameResultPreparing
        -- ^ The frame is currently being prepared and rendered by GTK.
        -- This is the initial state.
        --
        -- /Since: 4.24/
        | FrameResultSkipped
        -- ^ GTK has determined that nothing needs to be rendered because
        -- there are no visual changes. No rendering will be submitted to
        -- the display server and because of that no information will
        -- be forthcoming from the display server.
        --
        -- The frame is complete.
        --
        -- /Since: 4.24/
        | FrameResultEmpty
        -- ^ GTK has determined that nothing needs to be rendered because
        -- there are no visual changes. This information has been submitted
        -- to the display server. The presentation time has been updated to
        -- reflect when this frame would have been displayed.
        --
        -- The frame is complete.
        --
        -- /Since: 4.24/
        | FrameResultSubmitted
        -- ^ A frame has been drawn and submitted to the display server, but
        -- the display server will not provide any further feedback about when
        -- or how the frame is going to be displayed.
        --
        -- The frame is complete.
        --
        -- /Since: 4.24/
        | FrameResultOutstanding
        -- ^ The frame has been drawn and submitted to the display server, but the
        -- display server has not yet replied what is going to happen with the
        -- rendered image.
        --
        -- /Since: 4.24/
        | FrameResultDiscarded
        -- ^ The frame has been drawn and submitted to the display server, but the
        -- display server has not displayed it. No presentation time will be available.
        --
        -- The frame is complete.
        --
        -- /Since: 4.24/
        | FrameResultPresented
        -- ^ The frame has been drawn and submitted to the display server, and the
        -- display server has rendered it and displayed the result. The presentation
        -- time is accurately reflecting when that happened.
        --
        -- The frame is complete.
        --
        -- /Since: 4.24/
        | AnotherFrameResult Int
        -- ^ Catch-all for unknown values
        deriving (Int -> FrameResult -> ShowS
    [FrameResult] -> ShowS
    FrameResult -> String
    (Int -> FrameResult -> ShowS)
    -> (FrameResult -> String)
    -> ([FrameResult] -> ShowS)
    -> Show FrameResult
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> FrameResult -> ShowS
    showsPrec :: Int -> FrameResult -> ShowS
    $cshow :: FrameResult -> String
    show :: FrameResult -> String
    $cshowList :: [FrameResult] -> ShowS
    showList :: [FrameResult] -> ShowS
    Show, FrameResult -> FrameResult -> Bool
    (FrameResult -> FrameResult -> Bool)
    -> (FrameResult -> FrameResult -> Bool) -> Eq FrameResult
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: FrameResult -> FrameResult -> Bool
    == :: FrameResult -> FrameResult -> Bool
    $c/= :: FrameResult -> FrameResult -> Bool
    /= :: FrameResult -> FrameResult -> Bool
    Eq)

    instance P.Enum FrameResult where
        fromEnum :: FrameResult -> Int
    fromEnum FrameResult
    FrameResultPreparing = Int
    0
        fromEnum FrameResult
    FrameResultSkipped = Int
    1
        fromEnum FrameResult
    FrameResultEmpty = Int
    2
        fromEnum FrameResult
    FrameResultSubmitted = Int
    3
        fromEnum FrameResult
    FrameResultOutstanding = Int
    4
        fromEnum FrameResult
    FrameResultDiscarded = Int
    5
        fromEnum FrameResult
    FrameResultPresented = Int
    6
        fromEnum (AnotherFrameResult Int
    k) = Int
    k

        toEnum :: Int -> FrameResult
    toEnum Int
    0 = FrameResult
    FrameResultPreparing
        toEnum Int
    1 = FrameResult
    FrameResultSkipped
        toEnum Int
    2 = FrameResult
    FrameResultEmpty
        toEnum Int
    3 = FrameResult
    FrameResultSubmitted
        toEnum Int
    4 = FrameResult
    FrameResultOutstanding
        toEnum Int
    5 = FrameResult
    FrameResultDiscarded
        toEnum Int
    6 = FrameResult
    FrameResultPresented
        toEnum Int
    k = Int -> FrameResult
    AnotherFrameResult Int
    k

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

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

    foreign import ccall "gdk_frame_result_get_type" c_gdk_frame_result_get_type ::
        IO GType

    instance B.Types.TypedObject FrameResult where
        glibType :: IO GType
    glibType = IO GType
    c_gdk_frame_result_get_type

    instance B.Types.BoxedEnum FrameResult

    -- Enum EventType
    -- | Specifies the type of the event.
    data EventType =
          EventTypeDelete
        -- ^ the window manager has requested that the toplevel surface be
        --   hidden or destroyed, usually when the user clicks on a special icon in the
        --   title bar.
        | EventTypeMotionNotify
        -- ^ the pointer (usually a mouse) has moved.
        | EventTypeButtonPress
        -- ^ a mouse button has been pressed.
        | 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 surface.
        | EventTypeLeaveNotify
        -- ^ the pointer has left the surface.
        | EventTypeFocusChange
        -- ^ the keyboard focus has entered or left the surface.
        | 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 surface while a drag is in progress.
        | EventTypeDragLeave
        -- ^ the mouse has left the surface while a drag is in progress.
        | EventTypeDragMotion
        -- ^ the mouse has moved in the surface while a drag is in
        --   progress.
        | EventTypeDropStart
        -- ^ a drop operation onto the surface has started.
        | EventTypeScroll
        -- ^ the scroll wheel was turned
        | EventTypeGrabBroken
        -- ^ a pointer or keyboard grab was broken.
        | EventTypeTouchBegin
        -- ^ A new touch event sequence has just started.
        | EventTypeTouchUpdate
        -- ^ A touch event sequence has been updated.
        | EventTypeTouchEnd
        -- ^ A touch event sequence has finished.
        | EventTypeTouchCancel
        -- ^ A touch event sequence has been canceled.
        | EventTypeTouchpadSwipe
        -- ^ A touchpad swipe gesture event, the current state
        --   is determined by its phase field.
        | EventTypeTouchpadPinch
        -- ^ A touchpad pinch gesture event, the current state
        --   is determined by its phase field.
        | EventTypePadButtonPress
        -- ^ A tablet pad button press event.
        | EventTypePadButtonRelease
        -- ^ A tablet pad button release event.
        | EventTypePadRing
        -- ^ A tablet pad axis event from a \"ring\".
        | EventTypePadStrip
        -- ^ A tablet pad axis event from a \"strip\".
        | EventTypePadGroupMode
        -- ^ A tablet pad group mode change.
        | EventTypeTouchpadHold
        -- ^ A touchpad hold gesture event, the current state is determined by its phase
        -- field.
        --
        -- /Since: 4.6/
        | EventTypePadDial
        -- ^ A tablet pad axis event from a \"dial\".
        | EventTypeEventLast
        -- ^ marks the end of the GdkEventType enumeration.
        | AnotherEventType Int
        -- ^ Catch-all for unknown values
        deriving (Int -> EventType -> ShowS
    [EventType] -> ShowS
    EventType -> String
    (Int -> EventType -> ShowS)
    -> (EventType -> String)
    -> ([EventType] -> ShowS)
    -> Show EventType
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> EventType -> ShowS
    showsPrec :: Int -> EventType -> ShowS
    $cshow :: EventType -> String
    show :: EventType -> String
    $cshowList :: [EventType] -> ShowS
    showList :: [EventType] -> ShowS
    Show, EventType -> EventType -> Bool
    (EventType -> EventType -> Bool)
    -> (EventType -> EventType -> Bool) -> Eq EventType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: EventType -> EventType -> Bool
    == :: EventType -> EventType -> Bool
    $c/= :: EventType -> EventType -> Bool
    /= :: EventType -> EventType -> Bool
    Eq)

    instance P.Enum EventType where
        fromEnum :: EventType -> Int
    fromEnum EventType
    EventTypeDelete = Int
    0
        fromEnum EventType
    EventTypeMotionNotify = Int
    1
        fromEnum EventType
    EventTypeButtonPress = Int
    2
        fromEnum EventType
    EventTypeButtonRelease = Int
    3
        fromEnum EventType
    EventTypeKeyPress = Int
    4
        fromEnum EventType
    EventTypeKeyRelease = Int
    5
        fromEnum EventType
    EventTypeEnterNotify = Int
    6
        fromEnum EventType
    EventTypeLeaveNotify = Int
    7
        fromEnum EventType
    EventTypeFocusChange = Int
    8
        fromEnum EventType
    EventTypeProximityIn = Int
    9
        fromEnum EventType
    EventTypeProximityOut = Int
    10
        fromEnum EventType
    EventTypeDragEnter = Int
    11
        fromEnum EventType
    EventTypeDragLeave = Int
    12
        fromEnum EventType
    EventTypeDragMotion = Int
    13
        fromEnum EventType
    EventTypeDropStart = Int
    14
        fromEnum EventType
    EventTypeScroll = Int
    15
        fromEnum EventType
    EventTypeGrabBroken = Int
    16
        fromEnum EventType
    EventTypeTouchBegin = Int
    17
        fromEnum EventType
    EventTypeTouchUpdate = Int
    18
        fromEnum EventType
    EventTypeTouchEnd = Int
    19
        fromEnum EventType
    EventTypeTouchCancel = Int
    20
        fromEnum EventType
    EventTypeTouchpadSwipe = Int
    21
        fromEnum EventType
    EventTypeTouchpadPinch = Int
    22
        fromEnum EventType
    EventTypePadButtonPress = Int
    23
        fromEnum EventType
    EventTypePadButtonRelease = Int
    24
        fromEnum EventType
    EventTypePadRing = Int
    25
        fromEnum EventType
    EventTypePadStrip = Int
    26
        fromEnum EventType
    EventTypePadGroupMode = Int
    27
        fromEnum EventType
    EventTypeTouchpadHold = Int
    28
        fromEnum EventType
    EventTypePadDial = Int
    29
        fromEnum EventType
    EventTypeEventLast = Int
    30
        fromEnum (AnotherEventType Int
    k) = Int
    k

        toEnum :: Int -> EventType
    toEnum Int
    0 = EventType
    EventTypeDelete
        toEnum Int
    1 = EventType
    EventTypeMotionNotify
        toEnum Int
    2 = EventType
    EventTypeButtonPress
        toEnum Int
    3 = EventType
    EventTypeButtonRelease
        toEnum Int
    4 = EventType
    EventTypeKeyPress
        toEnum Int
    5 = EventType
    EventTypeKeyRelease
        toEnum Int
    6 = EventType
    EventTypeEnterNotify
        toEnum Int
    7 = EventType
    EventTypeLeaveNotify
        toEnum Int
    8 = EventType
    EventTypeFocusChange
        toEnum Int
    9 = EventType
    EventTypeProximityIn
        toEnum Int
    10 = EventType
    EventTypeProximityOut
        toEnum Int
    11 = EventType
    EventTypeDragEnter
        toEnum Int
    12 = EventType
    EventTypeDragLeave
        toEnum Int
    13 = EventType
    EventTypeDragMotion
        toEnum Int
    14 = EventType
    EventTypeDropStart
        toEnum Int
    15 = EventType
    EventTypeScroll
        toEnum Int
    16 = EventType
    EventTypeGrabBroken
        toEnum Int
    17 = EventType
    EventTypeTouchBegin
        toEnum Int
    18 = EventType
    EventTypeTouchUpdate
        toEnum Int
    19 = EventType
    EventTypeTouchEnd
        toEnum Int
    20 = EventType
    EventTypeTouchCancel
        toEnum Int
    21 = EventType
    EventTypeTouchpadSwipe
        toEnum Int
    22 = EventType
    EventTypeTouchpadPinch
        toEnum Int
    23 = EventType
    EventTypePadButtonPress
        toEnum Int
    24 = EventType
    EventTypePadButtonRelease
        toEnum Int
    25 = EventType
    EventTypePadRing
        toEnum Int
    26 = EventType
    EventTypePadStrip
        toEnum Int
    27 = EventType
    EventTypePadGroupMode
        toEnum Int
    28 = EventType
    EventTypeTouchpadHold
        toEnum Int
    29 = EventType
    EventTypePadDial
        toEnum Int
    30 = EventType
    EventTypeEventLast
        toEnum Int
    k = Int -> EventType
    AnotherEventType Int
    k

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

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

    foreign import ccall "gdk_event_type_get_type" c_gdk_event_type_get_type ::
        IO GType

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

    instance B.Types.BoxedEnum EventType

    -- Enum DragCancelReason
    -- | Used in @GdkDrag@ to the reason of a cancelled DND operation.
    data DragCancelReason =
          DragCancelReasonNoTarget
        -- ^ There is no suitable drop target.
        | DragCancelReasonUserCancelled
        -- ^ Drag cancelled by the user
        | DragCancelReasonError
        -- ^ Unspecified error.
        | AnotherDragCancelReason Int
        -- ^ Catch-all for unknown values
        deriving (Int -> DragCancelReason -> ShowS
    [DragCancelReason] -> ShowS
    DragCancelReason -> String
    (Int -> DragCancelReason -> ShowS)
    -> (DragCancelReason -> String)
    -> ([DragCancelReason] -> ShowS)
    -> Show DragCancelReason
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> DragCancelReason -> ShowS
    showsPrec :: Int -> DragCancelReason -> ShowS
    $cshow :: DragCancelReason -> String
    show :: DragCancelReason -> String
    $cshowList :: [DragCancelReason] -> ShowS
    showList :: [DragCancelReason] -> ShowS
    Show, DragCancelReason -> DragCancelReason -> Bool
    (DragCancelReason -> DragCancelReason -> Bool)
    -> (DragCancelReason -> DragCancelReason -> Bool)
    -> Eq DragCancelReason
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: DragCancelReason -> DragCancelReason -> Bool
    == :: DragCancelReason -> DragCancelReason -> Bool
    $c/= :: DragCancelReason -> DragCancelReason -> Bool
    /= :: DragCancelReason -> DragCancelReason -> Bool
    Eq)

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

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

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

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

    foreign import ccall "gdk_drag_cancel_reason_get_type" c_gdk_drag_cancel_reason_get_type ::
        IO GType

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

    instance B.Types.BoxedEnum DragCancelReason

    -- Enum DmabufError
    -- | Error enumeration for @GdkDmabufTexture@.
    --
    -- /Since: 4.14/
    data DmabufError =
          DmabufErrorNotAvailable
        -- ^ Dmabuf support is not available, because the OS
        --   is not Linux, or it was explicitly disabled at compile- or runtime
        | DmabufErrorUnsupportedFormat
        -- ^ The requested format is not supported
        | DmabufErrorCreationFailed
        -- ^ GTK failed to create the resource for other
        --   reasons
        | AnotherDmabufError Int
        -- ^ Catch-all for unknown values
        deriving (Int -> DmabufError -> ShowS
    [DmabufError] -> ShowS
    DmabufError -> String
    (Int -> DmabufError -> ShowS)
    -> (DmabufError -> String)
    -> ([DmabufError] -> ShowS)
    -> Show DmabufError
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> DmabufError -> ShowS
    showsPrec :: Int -> DmabufError -> ShowS
    $cshow :: DmabufError -> String
    show :: DmabufError -> String
    $cshowList :: [DmabufError] -> ShowS
    showList :: [DmabufError] -> ShowS
    Show, DmabufError -> DmabufError -> Bool
    (DmabufError -> DmabufError -> Bool)
    -> (DmabufError -> DmabufError -> Bool) -> Eq DmabufError
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: DmabufError -> DmabufError -> Bool
    == :: DmabufError -> DmabufError -> Bool
    $c/= :: DmabufError -> DmabufError -> Bool
    /= :: DmabufError -> DmabufError -> Bool
    Eq)

    instance P.Enum DmabufError where
        fromEnum :: DmabufError -> Int
    fromEnum DmabufError
    DmabufErrorNotAvailable = Int
    0
        fromEnum DmabufError
    DmabufErrorUnsupportedFormat = Int
    1
        fromEnum DmabufError
    DmabufErrorCreationFailed = Int
    2
        fromEnum (AnotherDmabufError Int
    k) = Int
    k

        toEnum :: Int -> DmabufError
    toEnum Int
    0 = DmabufError
    DmabufErrorNotAvailable
        toEnum Int
    1 = DmabufError
    DmabufErrorUnsupportedFormat
        toEnum Int
    2 = DmabufError
    DmabufErrorCreationFailed
        toEnum Int
    k = Int -> DmabufError
    AnotherDmabufError Int
    k

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

    instance GErrorClass DmabufError where
        gerrorClassDomain :: DmabufError -> Text
    gerrorClassDomain DmabufError
    _ = Text
    "gdk-dmabuf-error-quark"

    -- | Catch exceptions of type `DmabufError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
    catchDmabufError ::
        IO a ->
        (DmabufError -> GErrorMessage -> IO a) ->
        IO a
    catchDmabufError :: forall a. IO a -> (DmabufError -> Text -> IO a) -> IO a
    catchDmabufError = IO a -> (DmabufError -> Text -> IO a) -> IO a
    forall err a.
    GErrorClass err =>
    IO a -> (err -> Text -> IO a) -> IO a
    catchGErrorJustDomain

    -- | Handle exceptions of type `DmabufError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
    handleDmabufError ::
        (DmabufError -> GErrorMessage -> IO a) ->
        IO a ->
        IO a
    handleDmabufError :: forall a. (DmabufError -> Text -> IO a) -> IO a -> IO a
    handleDmabufError = (DmabufError -> Text -> IO a) -> IO a -> IO a
    forall err a.
    GErrorClass err =>
    (err -> Text -> IO a) -> IO a -> IO a
    handleGErrorJustDomain

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

    foreign import ccall "gdk_dmabuf_error_get_type" c_gdk_dmabuf_error_get_type ::
        IO GType

    instance B.Types.TypedObject DmabufError where
        glibType :: IO GType
    glibType = IO GType
    c_gdk_dmabuf_error_get_type

    instance B.Types.BoxedEnum DmabufError

    -- Enum DeviceToolType
    -- | Indicates the specific type of tool being used being a tablet. Such as an
    -- airbrush, pencil, etc.
    data DeviceToolType =
          DeviceToolTypeUnknown
        -- ^ Tool is of an unknown type.
        | DeviceToolTypePen
        -- ^ Tool is a standard tablet stylus.
        | DeviceToolTypeEraser
        -- ^ Tool is standard tablet eraser.
        | DeviceToolTypeBrush
        -- ^ Tool is a brush stylus.
        | DeviceToolTypePencil
        -- ^ Tool is a pencil stylus.
        | DeviceToolTypeAirbrush
        -- ^ Tool is an airbrush stylus.
        | DeviceToolTypeMouse
        -- ^ Tool is a mouse.
        | DeviceToolTypeLens
        -- ^ Tool is a lens cursor.
        | AnotherDeviceToolType Int
        -- ^ Catch-all for unknown values
        deriving (Int -> DeviceToolType -> ShowS
    [DeviceToolType] -> ShowS
    DeviceToolType -> String
    (Int -> DeviceToolType -> ShowS)
    -> (DeviceToolType -> String)
    -> ([DeviceToolType] -> ShowS)
    -> Show DeviceToolType
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> DeviceToolType -> ShowS
    showsPrec :: Int -> DeviceToolType -> ShowS
    $cshow :: DeviceToolType -> String
    show :: DeviceToolType -> String
    $cshowList :: [DeviceToolType] -> ShowS
    showList :: [DeviceToolType] -> ShowS
    Show, DeviceToolType -> DeviceToolType -> Bool
    (DeviceToolType -> DeviceToolType -> Bool)
    -> (DeviceToolType -> DeviceToolType -> Bool) -> Eq DeviceToolType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: DeviceToolType -> DeviceToolType -> Bool
    == :: DeviceToolType -> DeviceToolType -> Bool
    $c/= :: DeviceToolType -> DeviceToolType -> Bool
    /= :: DeviceToolType -> DeviceToolType -> Bool
    Eq)

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

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

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

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

    foreign import ccall "gdk_device_tool_type_get_type" c_gdk_device_tool_type_get_type ::
        IO GType

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

    instance B.Types.BoxedEnum DeviceToolType

    -- Enum DevicePadFeature
    -- | A pad feature.
    data DevicePadFeature =
          DevicePadFeatureButton
        -- ^ a button
        | DevicePadFeatureRing
        -- ^ a ring-shaped interactive area
        | DevicePadFeatureStrip
        -- ^ a straight interactive area
        | AnotherDevicePadFeature Int
        -- ^ Catch-all for unknown values
        deriving (Int -> DevicePadFeature -> ShowS
    [DevicePadFeature] -> ShowS
    DevicePadFeature -> String
    (Int -> DevicePadFeature -> ShowS)
    -> (DevicePadFeature -> String)
    -> ([DevicePadFeature] -> ShowS)
    -> Show DevicePadFeature
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> DevicePadFeature -> ShowS
    showsPrec :: Int -> DevicePadFeature -> ShowS
    $cshow :: DevicePadFeature -> String
    show :: DevicePadFeature -> String
    $cshowList :: [DevicePadFeature] -> ShowS
    showList :: [DevicePadFeature] -> ShowS
    Show, DevicePadFeature -> DevicePadFeature -> Bool
    (DevicePadFeature -> DevicePadFeature -> Bool)
    -> (DevicePadFeature -> DevicePadFeature -> Bool)
    -> Eq DevicePadFeature
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: DevicePadFeature -> DevicePadFeature -> Bool
    == :: DevicePadFeature -> DevicePadFeature -> Bool
    $c/= :: DevicePadFeature -> DevicePadFeature -> Bool
    /= :: DevicePadFeature -> DevicePadFeature -> Bool
    Eq)

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

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

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

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

    foreign import ccall "gdk_device_pad_feature_get_type" c_gdk_device_pad_feature_get_type ::
        IO GType

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

    instance B.Types.BoxedEnum DevicePadFeature

    -- Enum CrossingMode
    -- | Specifies the crossing mode for enter and leave events.
    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 surface.
        | CrossingModeTouchEnd
        -- ^ crossing because a touch sequence has ended,
        --   this event is synthetic as the pointer might have not left the surface.
        | 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 surface.
        | AnotherCrossingMode Int
        -- ^ Catch-all for unknown values
        deriving (Int -> CrossingMode -> ShowS
    [CrossingMode] -> ShowS
    CrossingMode -> String
    (Int -> CrossingMode -> ShowS)
    -> (CrossingMode -> String)
    -> ([CrossingMode] -> ShowS)
    -> Show CrossingMode
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> CrossingMode -> ShowS
    showsPrec :: Int -> CrossingMode -> ShowS
    $cshow :: CrossingMode -> String
    show :: CrossingMode -> String
    $cshowList :: [CrossingMode] -> ShowS
    showList :: [CrossingMode] -> ShowS
    Show, CrossingMode -> CrossingMode -> Bool
    (CrossingMode -> CrossingMode -> Bool)
    -> (CrossingMode -> CrossingMode -> Bool) -> Eq CrossingMode
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: CrossingMode -> CrossingMode -> Bool
    == :: CrossingMode -> CrossingMode -> Bool
    $c/= :: CrossingMode -> CrossingMode -> Bool
    /= :: CrossingMode -> CrossingMode -> Bool
    Eq)

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

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

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

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

    foreign import ccall "gdk_crossing_mode_get_type" c_gdk_crossing_mode_get_type ::
        IO GType

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

    instance B.Types.BoxedEnum CrossingMode

    -- Enum ColorChannel
    -- | Enumerates the color channels of RGBA values as used in
    -- @GdkColor@ and OpenGL\/Vulkan shaders.
    --
    -- Note that this is not the order of pixel values in Cairo
    -- and @GdkMemoryFormat@ can have many different orders.
    --
    -- /Since: 4.22/
    data ColorChannel =
          ColorChannelRed
        -- ^ The red color channel, aka 0
        | ColorChannelGreen
        -- ^ The green color channel, aka 1
        | ColorChannelBlue
        -- ^ The blue color channel, aka 2
        | ColorChannelAlpha
        -- ^ The alpha color channel, aka 3
        | AnotherColorChannel Int
        -- ^ Catch-all for unknown values
        deriving (Int -> ColorChannel -> ShowS
    [ColorChannel] -> ShowS
    ColorChannel -> String
    (Int -> ColorChannel -> ShowS)
    -> (ColorChannel -> String)
    -> ([ColorChannel] -> ShowS)
    -> Show ColorChannel
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> ColorChannel -> ShowS
    showsPrec :: Int -> ColorChannel -> ShowS
    $cshow :: ColorChannel -> String
    show :: ColorChannel -> String
    $cshowList :: [ColorChannel] -> ShowS
    showList :: [ColorChannel] -> ShowS
    Show, ColorChannel -> ColorChannel -> Bool
    (ColorChannel -> ColorChannel -> Bool)
    -> (ColorChannel -> ColorChannel -> Bool) -> Eq ColorChannel
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: ColorChannel -> ColorChannel -> Bool
    == :: ColorChannel -> ColorChannel -> Bool
    $c/= :: ColorChannel -> ColorChannel -> Bool
    /= :: ColorChannel -> ColorChannel -> Bool
    Eq)

    instance P.Enum ColorChannel where
        fromEnum :: ColorChannel -> Int
    fromEnum ColorChannel
    ColorChannelRed = Int
    0
        fromEnum ColorChannel
    ColorChannelGreen = Int
    1
        fromEnum ColorChannel
    ColorChannelBlue = Int
    2
        fromEnum ColorChannel
    ColorChannelAlpha = Int
    3
        fromEnum (AnotherColorChannel Int
    k) = Int
    k

        toEnum :: Int -> ColorChannel
    toEnum Int
    0 = ColorChannel
    ColorChannelRed
        toEnum Int
    1 = ColorChannel
    ColorChannelGreen
        toEnum Int
    2 = ColorChannel
    ColorChannelBlue
        toEnum Int
    3 = ColorChannel
    ColorChannelAlpha
        toEnum Int
    k = Int -> ColorChannel
    AnotherColorChannel Int
    k

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

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

    foreign import ccall "gdk_color_channel_get_type" c_gdk_color_channel_get_type ::
        IO GType

    instance B.Types.TypedObject ColorChannel where
        glibType :: IO GType
    glibType = IO GType
    c_gdk_color_channel_get_type

    instance B.Types.BoxedEnum ColorChannel

    -- Enum CicpRange
    -- | The values of this enumeration describe whether image data uses
    -- the full range of 8-bit values.
    --
    -- In digital broadcasting, it is common to reserve the lowest and
    -- highest values. Typically the allowed values for the narrow range
    -- are 16-235 for Y and 16-240 for u,v (when dealing with YUV data).
    --
    -- /Since: 4.16/
    data CicpRange =
          CicpRangeNarrow
        -- ^ The values use the range of 16-235 (for Y) and 16-240 for u and v.
        | CicpRangeFull
        -- ^ The values use the full range.
        | AnotherCicpRange Int
        -- ^ Catch-all for unknown values
        deriving (Int -> CicpRange -> ShowS
    [CicpRange] -> ShowS
    CicpRange -> String
    (Int -> CicpRange -> ShowS)
    -> (CicpRange -> String)
    -> ([CicpRange] -> ShowS)
    -> Show CicpRange
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> CicpRange -> ShowS
    showsPrec :: Int -> CicpRange -> ShowS
    $cshow :: CicpRange -> String
    show :: CicpRange -> String
    $cshowList :: [CicpRange] -> ShowS
    showList :: [CicpRange] -> ShowS
    Show, CicpRange -> CicpRange -> Bool
    (CicpRange -> CicpRange -> Bool)
    -> (CicpRange -> CicpRange -> Bool) -> Eq CicpRange
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: CicpRange -> CicpRange -> Bool
    == :: CicpRange -> CicpRange -> Bool
    $c/= :: CicpRange -> CicpRange -> Bool
    /= :: CicpRange -> CicpRange -> Bool
    Eq)

    instance P.Enum CicpRange where
        fromEnum :: CicpRange -> Int
    fromEnum CicpRange
    CicpRangeNarrow = Int
    0
        fromEnum CicpRange
    CicpRangeFull = Int
    1
        fromEnum (AnotherCicpRange Int
    k) = Int
    k

        toEnum :: Int -> CicpRange
    toEnum Int
    0 = CicpRange
    CicpRangeNarrow
        toEnum Int
    1 = CicpRange
    CicpRangeFull
        toEnum Int
    k = Int -> CicpRange
    AnotherCicpRange Int
    k

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

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

    foreign import ccall "gdk_cicp_range_get_type" c_gdk_cicp_range_get_type ::
        IO GType

    instance B.Types.TypedObject CicpRange where
        glibType :: IO GType
    glibType = IO GType
    c_gdk_cicp_range_get_type

    instance B.Types.BoxedEnum CicpRange

    -- Enum AxisUse
    -- | Defines how device axes are interpreted by GTK.
    --
    -- 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.
        | AxisUseDeltaX
        -- ^ the axis is used as the scroll x delta
        | AxisUseDeltaY
        -- ^ the axis is used as the scroll y delta
        | 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
        | AxisUseRotation
        -- ^ the axis is used for pen rotation information
        | AxisUseSlider
        -- ^ the axis is used for pen slider information
        | AxisUseLast
        -- ^ a constant equal to the numerically highest axis value.
        | AnotherAxisUse Int
        -- ^ Catch-all for unknown values
        deriving (Int -> AxisUse -> ShowS
    [AxisUse] -> ShowS
    AxisUse -> String
    (Int -> AxisUse -> ShowS)
    -> (AxisUse -> String) -> ([AxisUse] -> ShowS) -> Show AxisUse
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> AxisUse -> ShowS
    showsPrec :: Int -> AxisUse -> ShowS
    $cshow :: AxisUse -> String
    show :: AxisUse -> String
    $cshowList :: [AxisUse] -> ShowS
    showList :: [AxisUse] -> ShowS
    Show, AxisUse -> AxisUse -> Bool
    (AxisUse -> AxisUse -> Bool)
    -> (AxisUse -> AxisUse -> Bool) -> Eq AxisUse
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: AxisUse -> AxisUse -> Bool
    == :: AxisUse -> AxisUse -> Bool
    $c/= :: AxisUse -> AxisUse -> Bool
    /= :: AxisUse -> AxisUse -> Bool
    Eq)

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

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

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

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

    foreign import ccall "gdk_axis_use_get_type" c_gdk_axis_use_get_type ::
        IO GType

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

    instance B.Types.BoxedEnum AxisUse