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

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

module GI.Gdk.Enums
    ( 

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

    AxisUse(..)                             ,


-- ** ByteOrder #enum:ByteOrder#

    ByteOrder(..)                           ,


-- ** CrossingMode #enum:CrossingMode#

    CrossingMode(..)                        ,


-- ** DevicePadFeature #enum:DevicePadFeature#

    DevicePadFeature(..)                    ,


-- ** DeviceToolType #enum:DeviceToolType#

    DeviceToolType(..)                      ,


-- ** DeviceType #enum:DeviceType#

    DeviceType(..)                          ,


-- ** DragCancelReason #enum:DragCancelReason#

    DragCancelReason(..)                    ,


-- ** EventType #enum:EventType#

    EventType(..)                           ,


-- ** FullscreenMode #enum:FullscreenMode#

    FullscreenMode(..)                      ,


-- ** GLError #enum:GLError#

    GLError(..)                             ,
    catchGLError                            ,
    handleGLError                           ,


-- ** GrabOwnership #enum:GrabOwnership#

    GrabOwnership(..)                       ,


-- ** GrabStatus #enum:GrabStatus#

    GrabStatus(..)                          ,


-- ** Gravity #enum:Gravity#

    Gravity(..)                             ,


-- ** InputMode #enum:InputMode#

    InputMode(..)                           ,


-- ** InputSource #enum:InputSource#

    InputSource(..)                         ,


-- ** MemoryFormat #enum:MemoryFormat#

    MemoryFormat(..)                        ,


-- ** ModifierIntent #enum:ModifierIntent#

    ModifierIntent(..)                      ,


-- ** NotifyType #enum:NotifyType#

    NotifyType(..)                          ,


-- ** ScrollDirection #enum:ScrollDirection#

    ScrollDirection(..)                     ,


-- ** SubpixelLayout #enum:SubpixelLayout#

    SubpixelLayout(..)                      ,


-- ** SurfaceEdge #enum:SurfaceEdge#

    SurfaceEdge(..)                         ,


-- ** SurfaceType #enum:SurfaceType#

    SurfaceType(..)                         ,


-- ** SurfaceTypeHint #enum:SurfaceTypeHint#

    SurfaceTypeHint(..)                     ,


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


-- Enum 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 VulkanErrorUnsupported = 0
    fromEnum VulkanErrorNotAvailable = 1
    fromEnum (AnotherVulkanError k :: Int
k) = Int
k

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

instance P.Ord VulkanError where
    compare :: VulkanError -> VulkanError -> Ordering
compare a :: VulkanError
a b :: 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 _ = "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 :: 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 :: (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

foreign import ccall "gdk_vulkan_error_get_type" c_gdk_vulkan_error_get_type :: 
    IO GType

instance BoxedEnum VulkanError where
    boxedEnumType :: VulkanError -> IO GType
boxedEnumType _ = IO GType
c_gdk_vulkan_error_get_type

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

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

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

foreign import ccall "gdk_touchpad_gesture_phase_get_type" c_gdk_touchpad_gesture_phase_get_type :: 
    IO GType

instance BoxedEnum TouchpadGesturePhase where
    boxedEnumType :: TouchpadGesturePhase -> IO GType
boxedEnumType _ = IO GType
c_gdk_touchpad_gesture_phase_get_type

-- Enum SurfaceTypeHint
-- | These are hints for the window manager that indicate what type of function
-- the window has. The window manager can use this when determining decoration
-- and behaviour of the window. The hint must be set before mapping the window.
-- 
-- See the <http://www.freedesktop.org/Standards/wm-spec Extended Window Manager Hints>
-- specification for more details about window types.
data SurfaceTypeHint = 
      SurfaceTypeHintNormal
    -- ^ Normal toplevel window.
    | SurfaceTypeHintDialog
    -- ^ Dialog window.
    | SurfaceTypeHintMenu
    -- ^ Window used to implement a menu; GTK uses
    --  this hint only for torn-off menus, see @/GtkTearoffMenuItem/@.
    | SurfaceTypeHintToolbar
    -- ^ Window used to implement toolbars.
    | SurfaceTypeHintSplashscreen
    -- ^ Window used to display a splash
    --  screen during application startup.
    | SurfaceTypeHintUtility
    -- ^ Utility windows which are not detached
    --  toolbars or dialogs.
    | SurfaceTypeHintDock
    -- ^ Used for creating dock or panel windows.
    | SurfaceTypeHintDesktop
    -- ^ Used for creating the desktop background
    --  window.
    | SurfaceTypeHintDropdownMenu
    -- ^ A menu that belongs to a menubar.
    | SurfaceTypeHintPopupMenu
    -- ^ A menu that does not belong to a menubar,
    --  e.g. a context menu.
    | SurfaceTypeHintTooltip
    -- ^ A tooltip.
    | SurfaceTypeHintNotification
    -- ^ A notification - typically a “bubble”
    --  that belongs to a status icon.
    | SurfaceTypeHintCombo
    -- ^ A popup from a combo box.
    | SurfaceTypeHintDnd
    -- ^ A window that is used to implement a DND cursor.
    | AnotherSurfaceTypeHint Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SurfaceTypeHint -> ShowS
[SurfaceTypeHint] -> ShowS
SurfaceTypeHint -> String
(Int -> SurfaceTypeHint -> ShowS)
-> (SurfaceTypeHint -> String)
-> ([SurfaceTypeHint] -> ShowS)
-> Show SurfaceTypeHint
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SurfaceTypeHint] -> ShowS
$cshowList :: [SurfaceTypeHint] -> ShowS
show :: SurfaceTypeHint -> String
$cshow :: SurfaceTypeHint -> String
showsPrec :: Int -> SurfaceTypeHint -> ShowS
$cshowsPrec :: Int -> SurfaceTypeHint -> ShowS
Show, SurfaceTypeHint -> SurfaceTypeHint -> Bool
(SurfaceTypeHint -> SurfaceTypeHint -> Bool)
-> (SurfaceTypeHint -> SurfaceTypeHint -> Bool)
-> Eq SurfaceTypeHint
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SurfaceTypeHint -> SurfaceTypeHint -> Bool
$c/= :: SurfaceTypeHint -> SurfaceTypeHint -> Bool
== :: SurfaceTypeHint -> SurfaceTypeHint -> Bool
$c== :: SurfaceTypeHint -> SurfaceTypeHint -> Bool
Eq)

instance P.Enum SurfaceTypeHint where
    fromEnum :: SurfaceTypeHint -> Int
fromEnum SurfaceTypeHintNormal = 0
    fromEnum SurfaceTypeHintDialog = 1
    fromEnum SurfaceTypeHintMenu = 2
    fromEnum SurfaceTypeHintToolbar = 3
    fromEnum SurfaceTypeHintSplashscreen = 4
    fromEnum SurfaceTypeHintUtility = 5
    fromEnum SurfaceTypeHintDock = 6
    fromEnum SurfaceTypeHintDesktop = 7
    fromEnum SurfaceTypeHintDropdownMenu = 8
    fromEnum SurfaceTypeHintPopupMenu = 9
    fromEnum SurfaceTypeHintTooltip = 10
    fromEnum SurfaceTypeHintNotification = 11
    fromEnum SurfaceTypeHintCombo = 12
    fromEnum SurfaceTypeHintDnd = 13
    fromEnum (AnotherSurfaceTypeHint k :: Int
k) = Int
k

    toEnum :: Int -> SurfaceTypeHint
toEnum 0 = SurfaceTypeHint
SurfaceTypeHintNormal
    toEnum 1 = SurfaceTypeHint
SurfaceTypeHintDialog
    toEnum 2 = SurfaceTypeHint
SurfaceTypeHintMenu
    toEnum 3 = SurfaceTypeHint
SurfaceTypeHintToolbar
    toEnum 4 = SurfaceTypeHint
SurfaceTypeHintSplashscreen
    toEnum 5 = SurfaceTypeHint
SurfaceTypeHintUtility
    toEnum 6 = SurfaceTypeHint
SurfaceTypeHintDock
    toEnum 7 = SurfaceTypeHint
SurfaceTypeHintDesktop
    toEnum 8 = SurfaceTypeHint
SurfaceTypeHintDropdownMenu
    toEnum 9 = SurfaceTypeHint
SurfaceTypeHintPopupMenu
    toEnum 10 = SurfaceTypeHint
SurfaceTypeHintTooltip
    toEnum 11 = SurfaceTypeHint
SurfaceTypeHintNotification
    toEnum 12 = SurfaceTypeHint
SurfaceTypeHintCombo
    toEnum 13 = SurfaceTypeHint
SurfaceTypeHintDnd
    toEnum k :: Int
k = Int -> SurfaceTypeHint
AnotherSurfaceTypeHint Int
k

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

foreign import ccall "gdk_surface_type_hint_get_type" c_gdk_surface_type_hint_get_type :: 
    IO GType

instance BoxedEnum SurfaceTypeHint where
    boxedEnumType :: SurfaceTypeHint -> IO GType
boxedEnumType _ = IO GType
c_gdk_surface_type_hint_get_type

-- Enum SurfaceType
-- | Describes the kind of surface.
data SurfaceType = 
      SurfaceTypeToplevel
    -- ^ toplevel window (used to implement @/GtkWindow/@)
    | SurfaceTypeChild
    -- ^ child surface (used to implement e.g. @/GtkEntry/@)
    | SurfaceTypeTemp
    -- ^ override redirect temporary surface (used to implement @/GtkMenu/@)
    | AnotherSurfaceType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SurfaceType -> ShowS
[SurfaceType] -> ShowS
SurfaceType -> String
(Int -> SurfaceType -> ShowS)
-> (SurfaceType -> String)
-> ([SurfaceType] -> ShowS)
-> Show SurfaceType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SurfaceType] -> ShowS
$cshowList :: [SurfaceType] -> ShowS
show :: SurfaceType -> String
$cshow :: SurfaceType -> String
showsPrec :: Int -> SurfaceType -> ShowS
$cshowsPrec :: Int -> SurfaceType -> ShowS
Show, SurfaceType -> SurfaceType -> Bool
(SurfaceType -> SurfaceType -> Bool)
-> (SurfaceType -> SurfaceType -> Bool) -> Eq SurfaceType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SurfaceType -> SurfaceType -> Bool
$c/= :: SurfaceType -> SurfaceType -> Bool
== :: SurfaceType -> SurfaceType -> Bool
$c== :: SurfaceType -> SurfaceType -> Bool
Eq)

instance P.Enum SurfaceType where
    fromEnum :: SurfaceType -> Int
fromEnum SurfaceTypeToplevel = 0
    fromEnum SurfaceTypeChild = 1
    fromEnum SurfaceTypeTemp = 2
    fromEnum (AnotherSurfaceType k :: Int
k) = Int
k

    toEnum :: Int -> SurfaceType
toEnum 0 = SurfaceType
SurfaceTypeToplevel
    toEnum 1 = SurfaceType
SurfaceTypeChild
    toEnum 2 = SurfaceType
SurfaceTypeTemp
    toEnum k :: Int
k = Int -> SurfaceType
AnotherSurfaceType Int
k

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

foreign import ccall "gdk_surface_type_get_type" c_gdk_surface_type_get_type :: 
    IO GType

instance BoxedEnum SurfaceType where
    boxedEnumType :: SurfaceType -> IO GType
boxedEnumType _ = IO GType
c_gdk_surface_type_get_type

-- 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 SurfaceEdgeNorthWest = 0
    fromEnum SurfaceEdgeNorth = 1
    fromEnum SurfaceEdgeNorthEast = 2
    fromEnum SurfaceEdgeWest = 3
    fromEnum SurfaceEdgeEast = 4
    fromEnum SurfaceEdgeSouthWest = 5
    fromEnum SurfaceEdgeSouth = 6
    fromEnum SurfaceEdgeSouthEast = 7
    fromEnum (AnotherSurfaceEdge k :: Int
k) = Int
k

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

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

foreign import ccall "gdk_surface_edge_get_type" c_gdk_surface_edge_get_type :: 
    IO GType

instance BoxedEnum SurfaceEdge where
    boxedEnumType :: SurfaceEdge -> IO GType
boxedEnumType _ = IO GType
c_gdk_surface_edge_get_type

-- 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 SubpixelLayoutUnknown = 0
    fromEnum SubpixelLayoutNone = 1
    fromEnum SubpixelLayoutHorizontalRgb = 2
    fromEnum SubpixelLayoutHorizontalBgr = 3
    fromEnum SubpixelLayoutVerticalRgb = 4
    fromEnum SubpixelLayoutVerticalBgr = 5
    fromEnum (AnotherSubpixelLayout k :: Int
k) = Int
k

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

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

foreign import ccall "gdk_subpixel_layout_get_type" c_gdk_subpixel_layout_get_type :: 
    IO GType

instance BoxedEnum SubpixelLayout where
    boxedEnumType :: SubpixelLayout -> IO GType
boxedEnumType _ = IO GType
c_gdk_subpixel_layout_get_type

-- 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.Event.eventGetScrollDeltas'
    | 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 ScrollDirectionUp = 0
    fromEnum ScrollDirectionDown = 1
    fromEnum ScrollDirectionLeft = 2
    fromEnum ScrollDirectionRight = 3
    fromEnum ScrollDirectionSmooth = 4
    fromEnum (AnotherScrollDirection k :: Int
k) = Int
k

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

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

foreign import ccall "gdk_scroll_direction_get_type" c_gdk_scroll_direction_get_type :: 
    IO GType

instance BoxedEnum ScrollDirection where
    boxedEnumType :: ScrollDirection -> IO GType
boxedEnumType _ = IO GType
c_gdk_scroll_direction_get_type

-- 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 NotifyTypeAncestor = 0
    fromEnum NotifyTypeVirtual = 1
    fromEnum NotifyTypeInferior = 2
    fromEnum NotifyTypeNonlinear = 3
    fromEnum NotifyTypeNonlinearVirtual = 4
    fromEnum NotifyTypeUnknown = 5
    fromEnum (AnotherNotifyType k :: Int
k) = Int
k

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

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

foreign import ccall "gdk_notify_type_get_type" c_gdk_notify_type_get_type :: 
    IO GType

instance BoxedEnum NotifyType where
    boxedEnumType :: NotifyType -> IO GType
boxedEnumType _ = IO GType
c_gdk_notify_type_get_type

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

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

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

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

foreign import ccall "gdk_modifier_intent_get_type" c_gdk_modifier_intent_get_type :: 
    IO GType

instance BoxedEnum ModifierIntent where
    boxedEnumType :: ModifierIntent -> IO GType
boxedEnumType _ = IO GType
c_gdk_modifier_intent_get_type

-- 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.
    | 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 MemoryFormatB8g8r8a8Premultiplied = 0
    fromEnum MemoryFormatA8r8g8b8Premultiplied = 1
    fromEnum MemoryFormatB8g8r8a8 = 2
    fromEnum MemoryFormatA8r8g8b8 = 3
    fromEnum MemoryFormatR8g8b8a8 = 4
    fromEnum MemoryFormatA8b8g8r8 = 5
    fromEnum MemoryFormatR8g8b8 = 6
    fromEnum MemoryFormatB8g8r8 = 7
    fromEnum MemoryFormatNFormats = 8
    fromEnum (AnotherMemoryFormat k :: Int
k) = Int
k

    toEnum :: Int -> MemoryFormat
toEnum 0 = MemoryFormat
MemoryFormatB8g8r8a8Premultiplied
    toEnum 1 = MemoryFormat
MemoryFormatA8r8g8b8Premultiplied
    toEnum 2 = MemoryFormat
MemoryFormatB8g8r8a8
    toEnum 3 = MemoryFormat
MemoryFormatA8r8g8b8
    toEnum 4 = MemoryFormat
MemoryFormatR8g8b8a8
    toEnum 5 = MemoryFormat
MemoryFormatA8b8g8r8
    toEnum 6 = MemoryFormat
MemoryFormatR8g8b8
    toEnum 7 = MemoryFormat
MemoryFormatB8g8r8
    toEnum 8 = MemoryFormat
MemoryFormatNFormats
    toEnum k :: Int
k = Int -> MemoryFormat
AnotherMemoryFormat Int
k

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

foreign import ccall "gdk_memory_format_get_type" c_gdk_memory_format_get_type :: 
    IO GType

instance BoxedEnum MemoryFormat where
    boxedEnumType :: MemoryFormat -> IO GType
boxedEnumType _ = IO GType
c_gdk_memory_format_get_type

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

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

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

foreign import ccall "gdk_input_source_get_type" c_gdk_input_source_get_type :: 
    IO GType

instance BoxedEnum InputSource where
    boxedEnumType :: InputSource -> IO GType
boxedEnumType _ = IO GType
c_gdk_input_source_get_type

-- Enum InputMode
-- | An enumeration that describes the mode of an input device.
data InputMode = 
      InputModeDisabled
    -- ^ the device is disabled and will not report any events.
    | InputModeScreen
    -- ^ the device is enabled. The device’s coordinate space
    --                   maps to the entire screen.
    | InputModeSurface
    -- ^ the device is enabled. The device’s coordinate space
    --                   is mapped to a single surface. The manner in which this surface
    --                   is chosen is undefined, but it will typically be the same
    --                   way in which the focus surface for key events is determined.
    | AnotherInputMode Int
    -- ^ Catch-all for unknown values
    deriving (Int -> InputMode -> ShowS
[InputMode] -> ShowS
InputMode -> String
(Int -> InputMode -> ShowS)
-> (InputMode -> String)
-> ([InputMode] -> ShowS)
-> Show InputMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [InputMode] -> ShowS
$cshowList :: [InputMode] -> ShowS
show :: InputMode -> String
$cshow :: InputMode -> String
showsPrec :: Int -> InputMode -> ShowS
$cshowsPrec :: Int -> InputMode -> ShowS
Show, InputMode -> InputMode -> Bool
(InputMode -> InputMode -> Bool)
-> (InputMode -> InputMode -> Bool) -> Eq InputMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: InputMode -> InputMode -> Bool
$c/= :: InputMode -> InputMode -> Bool
== :: InputMode -> InputMode -> Bool
$c== :: InputMode -> InputMode -> Bool
Eq)

instance P.Enum InputMode where
    fromEnum :: InputMode -> Int
fromEnum InputModeDisabled = 0
    fromEnum InputModeScreen = 1
    fromEnum InputModeSurface = 2
    fromEnum (AnotherInputMode k :: Int
k) = Int
k

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

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

foreign import ccall "gdk_input_mode_get_type" c_gdk_input_mode_get_type :: 
    IO GType

instance BoxedEnum InputMode where
    boxedEnumType :: InputMode -> IO GType
boxedEnumType _ = IO GType
c_gdk_input_mode_get_type

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

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

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

foreign import ccall "gdk_gravity_get_type" c_gdk_gravity_get_type :: 
    IO GType

instance BoxedEnum Gravity where
    boxedEnumType :: Gravity -> IO GType
boxedEnumType _ = IO GType
c_gdk_gravity_get_type

-- Enum GrabStatus
-- | Returned by @/gdk_device_grab()/@ to indicate success or the reason for the
-- failure of the grab attempt.
data GrabStatus = 
      GrabStatusSuccess
    -- ^ the resource was successfully grabbed.
    | GrabStatusAlreadyGrabbed
    -- ^ the resource is actively grabbed by another client.
    | GrabStatusInvalidTime
    -- ^ the resource was grabbed more recently than the
    --  specified time.
    | GrabStatusNotViewable
    -- ^ the grab surface or the /@confineTo@/ surface are not
    --  viewable.
    | GrabStatusFrozen
    -- ^ the resource is frozen by an active grab of another client.
    | GrabStatusFailed
    -- ^ the grab failed for some other reason
    | AnotherGrabStatus Int
    -- ^ Catch-all for unknown values
    deriving (Int -> GrabStatus -> ShowS
[GrabStatus] -> ShowS
GrabStatus -> String
(Int -> GrabStatus -> ShowS)
-> (GrabStatus -> String)
-> ([GrabStatus] -> ShowS)
-> Show GrabStatus
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GrabStatus] -> ShowS
$cshowList :: [GrabStatus] -> ShowS
show :: GrabStatus -> String
$cshow :: GrabStatus -> String
showsPrec :: Int -> GrabStatus -> ShowS
$cshowsPrec :: Int -> GrabStatus -> ShowS
Show, GrabStatus -> GrabStatus -> Bool
(GrabStatus -> GrabStatus -> Bool)
-> (GrabStatus -> GrabStatus -> Bool) -> Eq GrabStatus
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GrabStatus -> GrabStatus -> Bool
$c/= :: GrabStatus -> GrabStatus -> Bool
== :: GrabStatus -> GrabStatus -> Bool
$c== :: GrabStatus -> GrabStatus -> Bool
Eq)

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

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

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

foreign import ccall "gdk_grab_status_get_type" c_gdk_grab_status_get_type :: 
    IO GType

instance BoxedEnum GrabStatus where
    boxedEnumType :: GrabStatus -> IO GType
boxedEnumType _ = IO GType
c_gdk_grab_status_get_type

-- Enum GrabOwnership
-- | Defines how device grabs interact with other devices.
data GrabOwnership = 
      GrabOwnershipNone
    -- ^ All other devices’ events are allowed.
    | GrabOwnershipSurface
    -- ^ Other devices’ events are blocked for the grab surface.
    | GrabOwnershipApplication
    -- ^ Other devices’ events are blocked for the whole application.
    | AnotherGrabOwnership Int
    -- ^ Catch-all for unknown values
    deriving (Int -> GrabOwnership -> ShowS
[GrabOwnership] -> ShowS
GrabOwnership -> String
(Int -> GrabOwnership -> ShowS)
-> (GrabOwnership -> String)
-> ([GrabOwnership] -> ShowS)
-> Show GrabOwnership
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GrabOwnership] -> ShowS
$cshowList :: [GrabOwnership] -> ShowS
show :: GrabOwnership -> String
$cshow :: GrabOwnership -> String
showsPrec :: Int -> GrabOwnership -> ShowS
$cshowsPrec :: Int -> GrabOwnership -> ShowS
Show, GrabOwnership -> GrabOwnership -> Bool
(GrabOwnership -> GrabOwnership -> Bool)
-> (GrabOwnership -> GrabOwnership -> Bool) -> Eq GrabOwnership
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GrabOwnership -> GrabOwnership -> Bool
$c/= :: GrabOwnership -> GrabOwnership -> Bool
== :: GrabOwnership -> GrabOwnership -> Bool
$c== :: GrabOwnership -> GrabOwnership -> Bool
Eq)

instance P.Enum GrabOwnership where
    fromEnum :: GrabOwnership -> Int
fromEnum GrabOwnershipNone = 0
    fromEnum GrabOwnershipSurface = 1
    fromEnum GrabOwnershipApplication = 2
    fromEnum (AnotherGrabOwnership k :: Int
k) = Int
k

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

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

foreign import ccall "gdk_grab_ownership_get_type" c_gdk_grab_ownership_get_type :: 
    IO GType

instance BoxedEnum GrabOwnership where
    boxedEnumType :: GrabOwnership -> IO GType
boxedEnumType _ = IO GType
c_gdk_grab_ownership_get_type

-- 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 GLErrorNotAvailable = 0
    fromEnum GLErrorUnsupportedFormat = 1
    fromEnum GLErrorUnsupportedProfile = 2
    fromEnum GLErrorCompilationFailed = 3
    fromEnum GLErrorLinkFailed = 4
    fromEnum (AnotherGLError k :: Int
k) = Int
k

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

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

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

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

foreign import ccall "gdk_gl_error_get_type" c_gdk_gl_error_get_type :: 
    IO GType

instance BoxedEnum GLError where
    boxedEnumType :: GLError -> IO GType
boxedEnumType _ = IO GType
c_gdk_gl_error_get_type

-- 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 FullscreenModeCurrentMonitor = 0
    fromEnum FullscreenModeAllMonitors = 1
    fromEnum (AnotherFullscreenMode k :: Int
k) = Int
k

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

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

foreign import ccall "gdk_fullscreen_mode_get_type" c_gdk_fullscreen_mode_get_type :: 
    IO GType

instance BoxedEnum FullscreenMode where
    boxedEnumType :: FullscreenMode -> IO GType
boxedEnumType _ = IO GType
c_gdk_fullscreen_mode_get_type

-- Enum EventType
-- | Specifies the type of the event.
-- 
-- Do not confuse these events with the signals that GTK+ widgets emit.
-- Although many of these events result in corresponding signals being emitted,
-- the events are often transformed or filtered along the way.
data EventType = 
      EventTypeNothing
    -- ^ a special code to indicate a null event.
    | 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.
    | EventTypeDestroy
    -- ^ the surface has been destroyed.
    | 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.
    | EventTypeConfigure
    -- ^ the size, position or stacking order of the surface has changed.
    --   Note that GTK+ discards these events for 'GI.Gdk.Enums.SurfaceTypeChild' surfaces.
    | 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. This event type
    --   was added in 2.8.
    | EventTypeTouchBegin
    -- ^ A new touch event sequence has just started. This event
    --   type was added in 3.4.
    | EventTypeTouchUpdate
    -- ^ A touch event sequence has been updated. This event type
    --   was added in 3.4.
    | EventTypeTouchEnd
    -- ^ A touch event sequence has finished. This event type
    --   was added in 3.4.
    | EventTypeTouchCancel
    -- ^ A touch event sequence has been canceled. This event type
    --   was added in 3.4.
    | EventTypeTouchpadSwipe
    -- ^ A touchpad swipe gesture event, the current state
    --   is determined by its phase field. This event type was added in 3.18.
    | EventTypeTouchpadPinch
    -- ^ A touchpad pinch gesture event, the current state
    --   is determined by its phase field. This event type was added in 3.18.
    | EventTypePadButtonPress
    -- ^ A tablet pad button press event. This event type
    --   was added in 3.22.
    | EventTypePadButtonRelease
    -- ^ A tablet pad button release event. This event type
    --   was added in 3.22.
    | EventTypePadRing
    -- ^ A tablet pad axis event from a \"ring\". This event type was
    --   added in 3.22.
    | EventTypePadStrip
    -- ^ A tablet pad axis event from a \"strip\". This event type was
    --   added in 3.22.
    | EventTypePadGroupMode
    -- ^ A tablet pad group mode change. This event type was
    --   added in 3.22.
    | EventTypeEventLast
    -- ^ marks the end of the GdkEventType enumeration. Added in 2.18
    | AnotherEventType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> EventType -> ShowS
[EventType] -> ShowS
EventType -> String
(Int -> EventType -> ShowS)
-> (EventType -> String)
-> ([EventType] -> ShowS)
-> Show EventType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [EventType] -> ShowS
$cshowList :: [EventType] -> ShowS
show :: EventType -> String
$cshow :: EventType -> String
showsPrec :: Int -> EventType -> ShowS
$cshowsPrec :: Int -> EventType -> ShowS
Show, EventType -> EventType -> Bool
(EventType -> EventType -> Bool)
-> (EventType -> EventType -> Bool) -> Eq EventType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: EventType -> EventType -> Bool
$c/= :: EventType -> EventType -> Bool
== :: EventType -> EventType -> Bool
$c== :: EventType -> EventType -> Bool
Eq)

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

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

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

foreign import ccall "gdk_event_type_get_type" c_gdk_event_type_get_type :: 
    IO GType

instance BoxedEnum EventType where
    boxedEnumType :: EventType -> IO GType
boxedEnumType _ = IO GType
c_gdk_event_type_get_type

-- 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 DragCancelReasonNoTarget = 0
    fromEnum DragCancelReasonUserCancelled = 1
    fromEnum DragCancelReasonError = 2
    fromEnum (AnotherDragCancelReason k :: Int
k) = Int
k

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

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

foreign import ccall "gdk_drag_cancel_reason_get_type" c_gdk_drag_cancel_reason_get_type :: 
    IO GType

instance BoxedEnum DragCancelReason where
    boxedEnumType :: DragCancelReason -> IO GType
boxedEnumType _ = IO GType
c_gdk_drag_cancel_reason_get_type

-- Enum DeviceType
-- | Indicates the device type.
data DeviceType = 
      DeviceTypeMaster
    -- ^ Device is a master (or virtual) device. There will
    --                          be an associated focus indicator on the screen.
    | DeviceTypeSlave
    -- ^ Device is a slave (or physical) device.
    | DeviceTypeFloating
    -- ^ Device is a physical device, currently not attached to
    --                            any seat.
    | AnotherDeviceType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> DeviceType -> ShowS
[DeviceType] -> ShowS
DeviceType -> String
(Int -> DeviceType -> ShowS)
-> (DeviceType -> String)
-> ([DeviceType] -> ShowS)
-> Show DeviceType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DeviceType] -> ShowS
$cshowList :: [DeviceType] -> ShowS
show :: DeviceType -> String
$cshow :: DeviceType -> String
showsPrec :: Int -> DeviceType -> ShowS
$cshowsPrec :: Int -> DeviceType -> ShowS
Show, DeviceType -> DeviceType -> Bool
(DeviceType -> DeviceType -> Bool)
-> (DeviceType -> DeviceType -> Bool) -> Eq DeviceType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DeviceType -> DeviceType -> Bool
$c/= :: DeviceType -> DeviceType -> Bool
== :: DeviceType -> DeviceType -> Bool
$c== :: DeviceType -> DeviceType -> Bool
Eq)

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

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

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

foreign import ccall "gdk_device_type_get_type" c_gdk_device_type_get_type :: 
    IO GType

instance BoxedEnum DeviceType where
    boxedEnumType :: DeviceType -> IO GType
boxedEnumType _ = IO GType
c_gdk_device_type_get_type

-- Enum DeviceToolType
-- | Indicates the specific type of tool being used being a tablet. Such as an
-- airbrush, pencil, etc.
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 DeviceToolTypeUnknown = 0
    fromEnum DeviceToolTypePen = 1
    fromEnum DeviceToolTypeEraser = 2
    fromEnum DeviceToolTypeBrush = 3
    fromEnum DeviceToolTypePencil = 4
    fromEnum DeviceToolTypeAirbrush = 5
    fromEnum DeviceToolTypeMouse = 6
    fromEnum DeviceToolTypeLens = 7
    fromEnum (AnotherDeviceToolType k :: Int
k) = Int
k

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

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

foreign import ccall "gdk_device_tool_type_get_type" c_gdk_device_tool_type_get_type :: 
    IO GType

instance BoxedEnum DeviceToolType where
    boxedEnumType :: DeviceToolType -> IO GType
boxedEnumType _ = IO GType
c_gdk_device_tool_type_get_type

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

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

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

foreign import ccall "gdk_device_pad_feature_get_type" c_gdk_device_pad_feature_get_type :: 
    IO GType

instance BoxedEnum DevicePadFeature where
    boxedEnumType :: DevicePadFeature -> IO GType
boxedEnumType _ = IO GType
c_gdk_device_pad_feature_get_type

-- 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 CrossingModeNormal = 0
    fromEnum CrossingModeGrab = 1
    fromEnum CrossingModeUngrab = 2
    fromEnum CrossingModeGtkGrab = 3
    fromEnum CrossingModeGtkUngrab = 4
    fromEnum CrossingModeStateChanged = 5
    fromEnum CrossingModeTouchBegin = 6
    fromEnum CrossingModeTouchEnd = 7
    fromEnum CrossingModeDeviceSwitch = 8
    fromEnum (AnotherCrossingMode k :: Int
k) = Int
k

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

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

foreign import ccall "gdk_crossing_mode_get_type" c_gdk_crossing_mode_get_type :: 
    IO GType

instance BoxedEnum CrossingMode where
    boxedEnumType :: CrossingMode -> IO GType
boxedEnumType _ = IO GType
c_gdk_crossing_mode_get_type

-- Enum ByteOrder
-- | A set of values describing the possible byte-orders
-- for storing pixel values in memory.
data ByteOrder = 
      ByteOrderLsbFirst
    -- ^ The values are stored with the least-significant byte
    --   first. For instance, the 32-bit value 0xffeecc would be stored
    --   in memory as 0xcc, 0xee, 0xff, 0x00.
    | ByteOrderMsbFirst
    -- ^ The values are stored with the most-significant byte
    --   first. For instance, the 32-bit value 0xffeecc would be stored
    --   in memory as 0x00, 0xff, 0xee, 0xcc.
    | AnotherByteOrder Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ByteOrder -> ShowS
[ByteOrder] -> ShowS
ByteOrder -> String
(Int -> ByteOrder -> ShowS)
-> (ByteOrder -> String)
-> ([ByteOrder] -> ShowS)
-> Show ByteOrder
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ByteOrder] -> ShowS
$cshowList :: [ByteOrder] -> ShowS
show :: ByteOrder -> String
$cshow :: ByteOrder -> String
showsPrec :: Int -> ByteOrder -> ShowS
$cshowsPrec :: Int -> ByteOrder -> ShowS
Show, ByteOrder -> ByteOrder -> Bool
(ByteOrder -> ByteOrder -> Bool)
-> (ByteOrder -> ByteOrder -> Bool) -> Eq ByteOrder
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ByteOrder -> ByteOrder -> Bool
$c/= :: ByteOrder -> ByteOrder -> Bool
== :: ByteOrder -> ByteOrder -> Bool
$c== :: ByteOrder -> ByteOrder -> Bool
Eq)

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

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

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

foreign import ccall "gdk_byte_order_get_type" c_gdk_byte_order_get_type :: 
    IO GType

instance BoxedEnum ByteOrder where
    boxedEnumType :: ByteOrder -> IO GType
boxedEnumType _ = IO GType
c_gdk_byte_order_get_type

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

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

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

foreign import ccall "gdk_axis_use_get_type" c_gdk_axis_use_get_type :: 
    IO GType

instance BoxedEnum AxisUse where
    boxedEnumType :: AxisUse -> IO GType
boxedEnumType _ = IO GType
c_gdk_axis_use_get_type