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

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

module GI.Gdk.Enums
    ( 

 -- * Enumerations


-- ** AxisUse #enum:AxisUse#

    AxisUse(..)                             ,


-- ** CrossingMode #enum:CrossingMode#

    CrossingMode(..)                        ,


-- ** DevicePadFeature #enum:DevicePadFeature#

    DevicePadFeature(..)                    ,


-- ** DeviceToolType #enum:DeviceToolType#

    DeviceToolType(..)                      ,


-- ** DragCancelReason #enum:DragCancelReason#

    DragCancelReason(..)                    ,


-- ** EventType #enum:EventType#

    EventType(..)                           ,


-- ** 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(..)                     ,


-- ** SubpixelLayout #enum:SubpixelLayout#

    SubpixelLayout(..)                      ,


-- ** SurfaceEdge #enum:SurfaceEdge#

    SurfaceEdge(..)                         ,


-- ** 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.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R


-- Enum VulkanError
-- | Error enumeration for t'GI.Gdk.Objects.VulkanContext.VulkanContext'.
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
showList :: [VulkanError] -> ShowS
$cshowList :: [VulkanError] -> ShowS
show :: VulkanError -> String
$cshow :: VulkanError -> String
showsPrec :: Int -> VulkanError -> ShowS
$cshowsPrec :: Int -> VulkanError -> ShowS
Show, VulkanError -> VulkanError -> Bool
(VulkanError -> VulkanError -> Bool)
-> (VulkanError -> VulkanError -> Bool) -> Eq VulkanError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VulkanError -> VulkanError -> Bool
$c/= :: VulkanError -> VulkanError -> Bool
== :: VulkanError -> VulkanError -> Bool
$c== :: 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
showList :: [TouchpadGesturePhase] -> ShowS
$cshowList :: [TouchpadGesturePhase] -> ShowS
show :: TouchpadGesturePhase -> String
$cshow :: TouchpadGesturePhase -> String
showsPrec :: Int -> TouchpadGesturePhase -> ShowS
$cshowsPrec :: Int -> TouchpadGesturePhase -> ShowS
Show, TouchpadGesturePhase -> TouchpadGesturePhase -> Bool
(TouchpadGesturePhase -> TouchpadGesturePhase -> Bool)
-> (TouchpadGesturePhase -> TouchpadGesturePhase -> Bool)
-> Eq TouchpadGesturePhase
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TouchpadGesturePhase -> TouchpadGesturePhase -> Bool
$c/= :: TouchpadGesturePhase -> TouchpadGesturePhase -> Bool
== :: TouchpadGesturePhase -> TouchpadGesturePhase -> Bool
$c== :: TouchpadGesturePhase -> TouchpadGesturePhase -> Bool
Eq)

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

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

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

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

foreign import ccall "gdk_touchpad_gesture_phase_get_type" c_gdk_touchpad_gesture_phase_get_type :: 
    IO GType

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

instance B.Types.BoxedEnum TouchpadGesturePhase

-- Enum 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
showList :: [SurfaceEdge] -> ShowS
$cshowList :: [SurfaceEdge] -> ShowS
show :: SurfaceEdge -> String
$cshow :: SurfaceEdge -> String
showsPrec :: Int -> SurfaceEdge -> ShowS
$cshowsPrec :: Int -> SurfaceEdge -> ShowS
Show, SurfaceEdge -> SurfaceEdge -> Bool
(SurfaceEdge -> SurfaceEdge -> Bool)
-> (SurfaceEdge -> SurfaceEdge -> Bool) -> Eq SurfaceEdge
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SurfaceEdge -> SurfaceEdge -> Bool
$c/= :: SurfaceEdge -> SurfaceEdge -> Bool
== :: SurfaceEdge -> SurfaceEdge -> Bool
$c== :: 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
showList :: [SubpixelLayout] -> ShowS
$cshowList :: [SubpixelLayout] -> ShowS
show :: SubpixelLayout -> String
$cshow :: SubpixelLayout -> String
showsPrec :: Int -> SubpixelLayout -> ShowS
$cshowsPrec :: Int -> SubpixelLayout -> ShowS
Show, SubpixelLayout -> SubpixelLayout -> Bool
(SubpixelLayout -> SubpixelLayout -> Bool)
-> (SubpixelLayout -> SubpixelLayout -> Bool) -> Eq SubpixelLayout
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SubpixelLayout -> SubpixelLayout -> Bool
$c/= :: SubpixelLayout -> SubpixelLayout -> Bool
== :: SubpixelLayout -> SubpixelLayout -> Bool
$c== :: SubpixelLayout -> SubpixelLayout -> Bool
Eq)

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

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

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

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

foreign import ccall "gdk_subpixel_layout_get_type" c_gdk_subpixel_layout_get_type :: 
    IO GType

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

instance B.Types.BoxedEnum SubpixelLayout

-- Enum 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
showList :: [ScrollDirection] -> ShowS
$cshowList :: [ScrollDirection] -> ShowS
show :: ScrollDirection -> String
$cshow :: ScrollDirection -> String
showsPrec :: Int -> ScrollDirection -> ShowS
$cshowsPrec :: Int -> ScrollDirection -> ShowS
Show, ScrollDirection -> ScrollDirection -> Bool
(ScrollDirection -> ScrollDirection -> Bool)
-> (ScrollDirection -> ScrollDirection -> Bool)
-> Eq ScrollDirection
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ScrollDirection -> ScrollDirection -> Bool
$c/= :: ScrollDirection -> ScrollDirection -> Bool
== :: ScrollDirection -> ScrollDirection -> Bool
$c== :: ScrollDirection -> ScrollDirection -> Bool
Eq)

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

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

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

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

foreign import ccall "gdk_scroll_direction_get_type" c_gdk_scroll_direction_get_type :: 
    IO GType

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

instance B.Types.BoxedEnum ScrollDirection

-- Enum 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
showList :: [NotifyType] -> ShowS
$cshowList :: [NotifyType] -> ShowS
show :: NotifyType -> String
$cshow :: NotifyType -> String
showsPrec :: Int -> NotifyType -> ShowS
$cshowsPrec :: Int -> NotifyType -> ShowS
Show, NotifyType -> NotifyType -> Bool
(NotifyType -> NotifyType -> Bool)
-> (NotifyType -> NotifyType -> Bool) -> Eq NotifyType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NotifyType -> NotifyType -> Bool
$c/= :: NotifyType -> NotifyType -> Bool
== :: NotifyType -> NotifyType -> Bool
$c== :: NotifyType -> NotifyType -> Bool
Eq)

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

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

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

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

foreign import ccall "gdk_notify_type_get_type" c_gdk_notify_type_get_type :: 
    IO GType

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

instance B.Types.BoxedEnum NotifyType

-- Enum MemoryFormat
-- | t'GI.Gdk.Enums.MemoryFormat' describes a format that bytes 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.
-- 
-- Its naming is modelled after VkFormat (see
-- https:\/\/www.khronos.org\/registry\/vulkan\/specs\/1.0\/html\/vkspec.html@/VkFormat/@
-- for details).
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.
    | 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
showList :: [MemoryFormat] -> ShowS
$cshowList :: [MemoryFormat] -> ShowS
show :: MemoryFormat -> String
$cshow :: MemoryFormat -> String
showsPrec :: Int -> MemoryFormat -> ShowS
$cshowsPrec :: Int -> MemoryFormat -> ShowS
Show, MemoryFormat -> MemoryFormat -> Bool
(MemoryFormat -> MemoryFormat -> Bool)
-> (MemoryFormat -> MemoryFormat -> Bool) -> Eq MemoryFormat
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MemoryFormat -> MemoryFormat -> Bool
$c/= :: MemoryFormat -> MemoryFormat -> Bool
== :: MemoryFormat -> MemoryFormat -> Bool
$c== :: 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
MemoryFormatNFormats = Int
9
    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
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
-- | The possible return values from 'GI.Gdk.Objects.KeyEvent.keyEventMatches'
-- describe how well an event matches a given keyval and modifiers.
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
showList :: [KeyMatch] -> ShowS
$cshowList :: [KeyMatch] -> ShowS
show :: KeyMatch -> String
$cshow :: KeyMatch -> String
showsPrec :: Int -> KeyMatch -> ShowS
$cshowsPrec :: Int -> KeyMatch -> ShowS
Show, KeyMatch -> KeyMatch -> Bool
(KeyMatch -> KeyMatch -> Bool)
-> (KeyMatch -> KeyMatch -> Bool) -> Eq KeyMatch
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: KeyMatch -> KeyMatch -> Bool
$c/= :: KeyMatch -> KeyMatch -> Bool
== :: KeyMatch -> KeyMatch -> Bool
$c== :: 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
showList :: [InputSource] -> ShowS
$cshowList :: [InputSource] -> ShowS
show :: InputSource -> String
$cshow :: InputSource -> String
showsPrec :: Int -> InputSource -> ShowS
$cshowsPrec :: Int -> InputSource -> ShowS
Show, InputSource -> InputSource -> Bool
(InputSource -> InputSource -> Bool)
-> (InputSource -> InputSource -> Bool) -> Eq InputSource
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: InputSource -> InputSource -> Bool
$c/= :: InputSource -> InputSource -> Bool
== :: InputSource -> InputSource -> Bool
$c== :: InputSource -> InputSource -> Bool
Eq)

instance P.Enum InputSource where
    fromEnum :: InputSource -> Int
fromEnum InputSource
InputSourceMouse = Int
0
    fromEnum InputSource
InputSourcePen = Int
1
    fromEnum InputSource
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 t'GI.Gdk.Structs.PopupLayout.PopupLayout'.
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
showList :: [Gravity] -> ShowS
$cshowList :: [Gravity] -> ShowS
show :: Gravity -> String
$cshow :: Gravity -> String
showsPrec :: Int -> Gravity -> ShowS
$cshowsPrec :: Int -> Gravity -> ShowS
Show, Gravity -> Gravity -> Bool
(Gravity -> Gravity -> Bool)
-> (Gravity -> Gravity -> Bool) -> Eq Gravity
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Gravity -> Gravity -> Bool
$c/= :: Gravity -> Gravity -> Bool
== :: Gravity -> Gravity -> Bool
$c== :: Gravity -> Gravity -> Bool
Eq)

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

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

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

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

foreign import ccall "gdk_gravity_get_type" c_gdk_gravity_get_type :: 
    IO GType

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

instance B.Types.BoxedEnum Gravity

-- Enum GLError
-- | Error enumeration for t'GI.Gdk.Objects.GLContext.GLContext'.
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
showList :: [GLError] -> ShowS
$cshowList :: [GLError] -> ShowS
show :: GLError -> String
$cshow :: GLError -> String
showsPrec :: Int -> GLError -> ShowS
$cshowsPrec :: Int -> GLError -> ShowS
Show, GLError -> GLError -> Bool
(GLError -> GLError -> Bool)
-> (GLError -> GLError -> Bool) -> Eq GLError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GLError -> GLError -> Bool
$c/= :: GLError -> GLError -> Bool
== :: GLError -> GLError -> Bool
$c== :: GLError -> GLError -> Bool
Eq)

instance P.Enum GLError where
    fromEnum :: GLError -> Int
fromEnum GLError
GLErrorNotAvailable = Int
0
    fromEnum GLError
GLErrorUnsupportedFormat = Int
1
    fromEnum GLError
GLErrorUnsupportedProfile = Int
2
    fromEnum 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 (in a multi-head setup) 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
showList :: [FullscreenMode] -> ShowS
$cshowList :: [FullscreenMode] -> ShowS
show :: FullscreenMode -> String
$cshow :: FullscreenMode -> String
showsPrec :: Int -> FullscreenMode -> ShowS
$cshowsPrec :: Int -> FullscreenMode -> ShowS
Show, FullscreenMode -> FullscreenMode -> Bool
(FullscreenMode -> FullscreenMode -> Bool)
-> (FullscreenMode -> FullscreenMode -> Bool) -> Eq FullscreenMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FullscreenMode -> FullscreenMode -> Bool
$c/= :: FullscreenMode -> FullscreenMode -> Bool
== :: FullscreenMode -> FullscreenMode -> Bool
$c== :: FullscreenMode -> FullscreenMode -> Bool
Eq)

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

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

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

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

foreign import ccall "gdk_fullscreen_mode_get_type" c_gdk_fullscreen_mode_get_type :: 
    IO GType

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

instance B.Types.BoxedEnum FullscreenMode

-- Enum 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.
    | 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
showList :: [EventType] -> ShowS
$cshowList :: [EventType] -> ShowS
show :: EventType -> String
$cshow :: EventType -> String
showsPrec :: Int -> EventType -> ShowS
$cshowsPrec :: Int -> EventType -> ShowS
Show, EventType -> EventType -> Bool
(EventType -> EventType -> Bool)
-> (EventType -> EventType -> Bool) -> Eq EventType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: EventType -> EventType -> Bool
$c/= :: EventType -> EventType -> Bool
== :: EventType -> EventType -> Bool
$c== :: EventType -> EventType -> Bool
Eq)

instance P.Enum EventType where
    fromEnum :: EventType -> Int
fromEnum EventType
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
EventTypeEventLast = Int
28
    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
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 t'GI.Gdk.Objects.Drag.Drag' 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
showList :: [DragCancelReason] -> ShowS
$cshowList :: [DragCancelReason] -> ShowS
show :: DragCancelReason -> String
$cshow :: DragCancelReason -> String
showsPrec :: Int -> DragCancelReason -> ShowS
$cshowsPrec :: Int -> DragCancelReason -> ShowS
Show, DragCancelReason -> DragCancelReason -> Bool
(DragCancelReason -> DragCancelReason -> Bool)
-> (DragCancelReason -> DragCancelReason -> Bool)
-> Eq DragCancelReason
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DragCancelReason -> DragCancelReason -> Bool
$c/= :: DragCancelReason -> DragCancelReason -> Bool
== :: DragCancelReason -> DragCancelReason -> Bool
$c== :: DragCancelReason -> DragCancelReason -> Bool
Eq)

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

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

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

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

foreign import ccall "gdk_drag_cancel_reason_get_type" c_gdk_drag_cancel_reason_get_type :: 
    IO GType

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

instance B.Types.BoxedEnum DragCancelReason

-- Enum 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
showList :: [DeviceToolType] -> ShowS
$cshowList :: [DeviceToolType] -> ShowS
show :: DeviceToolType -> String
$cshow :: DeviceToolType -> String
showsPrec :: Int -> DeviceToolType -> ShowS
$cshowsPrec :: Int -> DeviceToolType -> ShowS
Show, DeviceToolType -> DeviceToolType -> Bool
(DeviceToolType -> DeviceToolType -> Bool)
-> (DeviceToolType -> DeviceToolType -> Bool) -> Eq DeviceToolType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DeviceToolType -> DeviceToolType -> Bool
$c/= :: DeviceToolType -> DeviceToolType -> Bool
== :: DeviceToolType -> DeviceToolType -> Bool
$c== :: DeviceToolType -> DeviceToolType -> Bool
Eq)

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

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

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

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

foreign import ccall "gdk_device_tool_type_get_type" c_gdk_device_tool_type_get_type :: 
    IO GType

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

instance B.Types.BoxedEnum DeviceToolType

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

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

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

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

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

foreign import ccall "gdk_device_pad_feature_get_type" c_gdk_device_pad_feature_get_type :: 
    IO GType

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

instance B.Types.BoxedEnum DevicePadFeature

-- Enum 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
showList :: [CrossingMode] -> ShowS
$cshowList :: [CrossingMode] -> ShowS
show :: CrossingMode -> String
$cshow :: CrossingMode -> String
showsPrec :: Int -> CrossingMode -> ShowS
$cshowsPrec :: Int -> CrossingMode -> ShowS
Show, CrossingMode -> CrossingMode -> Bool
(CrossingMode -> CrossingMode -> Bool)
-> (CrossingMode -> CrossingMode -> Bool) -> Eq CrossingMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CrossingMode -> CrossingMode -> Bool
$c/= :: CrossingMode -> CrossingMode -> Bool
== :: CrossingMode -> CrossingMode -> Bool
$c== :: CrossingMode -> CrossingMode -> Bool
Eq)

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

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

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

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

foreign import ccall "gdk_crossing_mode_get_type" c_gdk_crossing_mode_get_type :: 
    IO GType

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

instance B.Types.BoxedEnum CrossingMode

-- Enum AxisUse
-- | An enumeration describing the way in which a device
-- axis (valuator) maps onto the predefined valuator
-- types that GTK understands.
-- 
-- Note that the X and Y axes are not really needed; pointer devices
-- report their location via the x\/y members of events regardless. Whether
-- X and Y are present as axes depends on the GDK backend.
data AxisUse = 
      AxisUseIgnore
    -- ^ the axis is ignored.
    | AxisUseX
    -- ^ the axis is used as the x axis.
    | AxisUseY
    -- ^ the axis is used as the y axis.
    | 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
showList :: [AxisUse] -> ShowS
$cshowList :: [AxisUse] -> ShowS
show :: AxisUse -> String
$cshow :: AxisUse -> String
showsPrec :: Int -> AxisUse -> ShowS
$cshowsPrec :: Int -> AxisUse -> ShowS
Show, AxisUse -> AxisUse -> Bool
(AxisUse -> AxisUse -> Bool)
-> (AxisUse -> AxisUse -> Bool) -> Eq AxisUse
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AxisUse -> AxisUse -> Bool
$c/= :: AxisUse -> AxisUse -> Bool
== :: AxisUse -> AxisUse -> Bool
$c== :: AxisUse -> AxisUse -> Bool
Eq)

instance P.Enum AxisUse where
    fromEnum :: AxisUse -> Int
fromEnum AxisUse
AxisUseIgnore = Int
0
    fromEnum AxisUse
AxisUseX = Int
1
    fromEnum AxisUse
AxisUseY = Int
2
    fromEnum AxisUse
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