{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE PatternSynonyms #-}

{-# OPTIONS_GHC -fno-warn-missing-pattern-synonym-signatures #-}
{-# OPTIONS_GHC -fno-warn-missing-signatures #-}

{-|

An enumeration of scancodes and keycodes, allowing you to pattern match on keyboard keys.

This module uses a relatively new GHC feature called @PatternSynonyms@ in order to provide pattern
matches over the underlying 'Scancode' or 'Keycode'. We do this so that you are also able to
work with vendor-specific or otherwise unknown codes.

-}

module SDL.Input.Keyboard.Codes
       (-- * Scancodes
        -- | Scancodes are codes that correspond to the physical position of a key, independent of the current keyboard layout.
        -- Scancodes are meant to be layout-independent. Think of this as \"the user pressed the Q key as it would be on a US QWERTY keyboard\" regardless of whether this is actually a European keyboard or a Dvorak keyboard or whatever. The scancode is always the same key position.
        -- 'Scancode' makes sense when you want key presses based on their location on a keyboard - for example, the traditional \"WASD\" layout used in first-person shooters.
        Scancode(..),
        pattern ScancodeUnknown,
        pattern ScancodeA,
        pattern ScancodeB,
        pattern ScancodeC,
        pattern ScancodeD,
        pattern ScancodeE,
        pattern ScancodeF,
        pattern ScancodeG,
        pattern ScancodeH,
        pattern ScancodeI,
        pattern ScancodeJ,
        pattern ScancodeK,
        pattern ScancodeL,
        pattern ScancodeM,
        pattern ScancodeN,
        pattern ScancodeO,
        pattern ScancodeP,
        pattern ScancodeQ,
        pattern ScancodeR,
        pattern ScancodeS,
        pattern ScancodeT,
        pattern ScancodeU,
        pattern ScancodeV,
        pattern ScancodeW,
        pattern ScancodeX,
        pattern ScancodeY,
        pattern ScancodeZ,
        pattern Scancode1,
        pattern Scancode2,
        pattern Scancode3,
        pattern Scancode4,
        pattern Scancode5,
        pattern Scancode6,
        pattern Scancode7,
        pattern Scancode8,
        pattern Scancode9,
        pattern Scancode0,
        pattern ScancodeReturn,
        pattern ScancodeEscape,
        pattern ScancodeBackspace,
        pattern ScancodeTab,
        pattern ScancodeSpace,
        pattern ScancodeMinus,
        pattern ScancodeEquals,
        pattern ScancodeLeftBracket,
        pattern ScancodeRightBracket,
        pattern ScancodeBackslash,
        pattern ScancodeNonUSHash,
        pattern ScancodeSemicolon,
        pattern ScancodeApostrophe,
        pattern ScancodeGrave,
        pattern ScancodeComma,
        pattern ScancodePeriod,
        pattern ScancodeSlash,
        pattern ScancodeCapsLock,
        pattern ScancodeF1,
        pattern ScancodeF2,
        pattern ScancodeF3,
        pattern ScancodeF4,
        pattern ScancodeF5,
        pattern ScancodeF6,
        pattern ScancodeF7,
        pattern ScancodeF8,
        pattern ScancodeF9,
        pattern ScancodeF10,
        pattern ScancodeF11,
        pattern ScancodeF12,
        pattern ScancodePrintScreen,
        pattern ScancodeScrollLock,
        pattern ScancodePause,
        pattern ScancodeInsert,
        pattern ScancodeHome,
        pattern ScancodePageUp,
        pattern ScancodeDelete,
        pattern ScancodeEnd,
        pattern ScancodePageDown,
        pattern ScancodeRight,
        pattern ScancodeLeft,
        pattern ScancodeDown,
        pattern ScancodeUp,
        pattern ScancodeNumLockClear,
        pattern ScancodeKPDivide,
        pattern ScancodeKPMultiply,
        pattern ScancodeKPMinus,
        pattern ScancodeKPPlus,
        pattern ScancodeKPEnter,
        pattern ScancodeKP1,
        pattern ScancodeKP2,
        pattern ScancodeKP3,
        pattern ScancodeKP4,
        pattern ScancodeKP5,
        pattern ScancodeKP6,
        pattern ScancodeKP7,
        pattern ScancodeKP8,
        pattern ScancodeKP9,
        pattern ScancodeKP0,
        pattern ScancodeKPPeriod,
        pattern ScancodeNonUSBackslash,
        pattern ScancodeApplication,
        pattern ScancodePower,
        pattern ScancodeKPEquals,
        pattern ScancodeF13,
        pattern ScancodeF14,
        pattern ScancodeF15,
        pattern ScancodeF16,
        pattern ScancodeF17,
        pattern ScancodeF18,
        pattern ScancodeF19,
        pattern ScancodeF20,
        pattern ScancodeF21,
        pattern ScancodeF22,
        pattern ScancodeF23,
        pattern ScancodeF24,
        pattern ScancodeExecute,
        pattern ScancodeHelp,
        pattern ScancodeMenu,
        pattern ScancodeSelect,
        pattern ScancodeStop,
        pattern ScancodeAgain,
        pattern ScancodeUndo,
        pattern ScancodeCut,
        pattern ScancodeCopy,
        pattern ScancodePaste,
        pattern ScancodeFind,
        pattern ScancodeMute,
        pattern ScancodeVolumeUp,
        pattern ScancodeVolumeDown,
        pattern ScancodeKPComma,
        pattern ScancodeKPEqualsAS400,
        pattern ScancodeInternational1,
        pattern ScancodeInternational2,
        pattern ScancodeInternational3,
        pattern ScancodeInternational4,
        pattern ScancodeInternational5,
        pattern ScancodeInternational6,
        pattern ScancodeInternational7,
        pattern ScancodeInternational8,
        pattern ScancodeInternational9,
        pattern ScancodeLang1,
        pattern ScancodeLang2,
        pattern ScancodeLang3,
        pattern ScancodeLang4,
        pattern ScancodeLang5,
        pattern ScancodeLang6,
        pattern ScancodeLang7,
        pattern ScancodeLang8,
        pattern ScancodeLang9,
        pattern ScancodeAltErase,
        pattern ScancodeSysReq,
        pattern ScancodeCancel,
        pattern ScancodeClear,
        pattern ScancodePrior,
        pattern ScancodeReturn2,
        pattern ScancodeSeparator,
        pattern ScancodeOut,
        pattern ScancodeOper,
        pattern ScancodeClearAgain,
        pattern ScancodeCrSel,
        pattern ScancodeExSel,
        pattern ScancodeKP00,
        pattern ScancodeKP000,
        pattern ScancodeThousandsSeparator,
        pattern ScancodeDecimalSeparator,
        pattern ScancodeCurrencyUnit,
        pattern ScancodeCurrencySubunit,
        pattern ScancodeLeftParen,
        pattern ScancodeRightParen,
        pattern ScancodeLeftBrace,
        pattern ScancodeRightBrace,
        pattern ScancodeKPTab,
        pattern ScancodeKPBackspace,
        pattern ScancodeKPA,
        pattern ScancodeKPB,
        pattern ScancodeKPC,
        pattern ScancodeKPD,
        pattern ScancodeKPE,
        pattern ScancodeKPF,
        pattern ScancodeKPXOR,
        pattern ScancodeKPPower,
        pattern ScancodeKPPercent,
        pattern ScancodeKPLess,
        pattern ScancodeKPGreater,
        pattern ScancodeKPAmpersand,
        pattern ScancodeKPDblAmpersand,
        pattern ScancodeKPVerticalBar,
        pattern ScancodeKPDblVerticalBar,
        pattern ScancodeKPColon,
        pattern ScancodeKPHash,
        pattern ScancodeKPSpace,
        pattern ScancodeKPAt,
        pattern ScancodeKPExclam,
        pattern ScancodeKPMemStore,
        pattern ScancodeKPMemRecall,
        pattern ScancodeKPMemClear,
        pattern ScancodeKPMemAdd,
        pattern ScancodeKPMemSubtract,
        pattern ScancodeKPMemMultiply,
        pattern ScancodeKPMemDivide,
        pattern ScancodeKPPlusMinus,
        pattern ScancodeKPClear,
        pattern ScancodeKPClearEntry,
        pattern ScancodeKPBinary,
        pattern ScancodeKPOctal,
        pattern ScancodeKPDecimal,
        pattern ScancodeKPHexadecimal,
        pattern ScancodeLCtrl,
        pattern ScancodeLShift,
        pattern ScancodeLAlt,
        pattern ScancodeLGUI,
        pattern ScancodeRCtrl,
        pattern ScancodeRShift,
        pattern ScancodeRAlt,
        pattern ScancodeRGUI,
        pattern ScancodeMode,
        pattern ScancodeAudioNext,
        pattern ScancodeAudioPrev,
        pattern ScancodeAudioStop,
        pattern ScancodeAudioPlay,
        pattern ScancodeAudioMute,
        pattern ScancodeMediaSelect,
        pattern ScancodeWWW,
        pattern ScancodeMail,
        pattern ScancodeCalculator,
        pattern ScancodeComputer,
        pattern ScancodeACSearch,
        pattern ScancodeACHome,
        pattern ScancodeACBack,
        pattern ScancodeACForward,
        pattern ScancodeACStop,
        pattern ScancodeACRefresh,
        pattern ScancodeACBookmarks,
        pattern ScancodeBrightnessDown,
        pattern ScancodeBrightnessUp,
        pattern ScancodeDisplaySwitch,
        pattern ScancodeKBDIllumToggle,
        pattern ScancodeKBDIllumDown,
        pattern ScancodeKBDIllumUp,
        pattern ScancodeEject,
        pattern ScancodeSleep,
        pattern ScancodeApp1,
        pattern ScancodeApp2,

        -- * Keycode
        -- | Keycodes are layout-dependent codes, in that the code you receive can change for the same physical key depending on the users keyboard layout.
        -- Think of this as "the user pressed the key that is labelled 'Q' on a specific keyboard."
        -- 'Keycode' makes sense when you are anticipating the user to press either keys that match some mneumonic, or they are entering text.
        Keycode(..),
        pattern KeycodeUnknown,
        pattern KeycodeReturn,
        pattern KeycodeEscape,
        pattern KeycodeBackspace,
        pattern KeycodeTab,
        pattern KeycodeSpace,
        pattern KeycodeExclaim,
        pattern KeycodeQuoteDbl,
        pattern KeycodeHash,
        pattern KeycodePercent,
        pattern KeycodeDollar,
        pattern KeycodeAmpersand,
        pattern KeycodeQuote,
        pattern KeycodeLeftParen,
        pattern KeycodeRightParen,
        pattern KeycodeAsterisk,
        pattern KeycodePlus,
        pattern KeycodeComma,
        pattern KeycodeMinus,
        pattern KeycodePeriod,
        pattern KeycodeSlash,
        pattern Keycode0,
        pattern Keycode1,
        pattern Keycode2,
        pattern Keycode3,
        pattern Keycode4,
        pattern Keycode5,
        pattern Keycode6,
        pattern Keycode7,
        pattern Keycode8,
        pattern Keycode9,
        pattern KeycodeColon,
        pattern KeycodeSemicolon,
        pattern KeycodeLess,
        pattern KeycodeEquals,
        pattern KeycodeGreater,
        pattern KeycodeQuestion,
        pattern KeycodeAt,
        pattern KeycodeLeftBracket,
        pattern KeycodeBackslash,
        pattern KeycodeRightBracket,
        pattern KeycodeCaret,
        pattern KeycodeUnderscore,
        pattern KeycodeBackquote,
        pattern KeycodeA,
        pattern KeycodeB,
        pattern KeycodeC,
        pattern KeycodeD,
        pattern KeycodeE,
        pattern KeycodeF,
        pattern KeycodeG,
        pattern KeycodeH,
        pattern KeycodeI,
        pattern KeycodeJ,
        pattern KeycodeK,
        pattern KeycodeL,
        pattern KeycodeM,
        pattern KeycodeN,
        pattern KeycodeO,
        pattern KeycodeP,
        pattern KeycodeQ,
        pattern KeycodeR,
        pattern KeycodeS,
        pattern KeycodeT,
        pattern KeycodeU,
        pattern KeycodeV,
        pattern KeycodeW,
        pattern KeycodeX,
        pattern KeycodeY,
        pattern KeycodeZ,
        pattern KeycodeCapsLock,
        pattern KeycodeF1,
        pattern KeycodeF2,
        pattern KeycodeF3,
        pattern KeycodeF4,
        pattern KeycodeF5,
        pattern KeycodeF6,
        pattern KeycodeF7,
        pattern KeycodeF8,
        pattern KeycodeF9,
        pattern KeycodeF10,
        pattern KeycodeF11,
        pattern KeycodeF12,
        pattern KeycodePrintScreen,
        pattern KeycodeScrollLock,
        pattern KeycodePause,
        pattern KeycodeInsert,
        pattern KeycodeHome,
        pattern KeycodePageUp,
        pattern KeycodeDelete,
        pattern KeycodeEnd,
        pattern KeycodePageDown,
        pattern KeycodeRight,
        pattern KeycodeLeft,
        pattern KeycodeDown,
        pattern KeycodeUp,
        pattern KeycodeNumLockClear,
        pattern KeycodeKPDivide,
        pattern KeycodeKPMultiply,
        pattern KeycodeKPMinus,
        pattern KeycodeKPPlus,
        pattern KeycodeKPEnter,
        pattern KeycodeKP1,
        pattern KeycodeKP2,
        pattern KeycodeKP3,
        pattern KeycodeKP4,
        pattern KeycodeKP5,
        pattern KeycodeKP6,
        pattern KeycodeKP7,
        pattern KeycodeKP8,
        pattern KeycodeKP9,
        pattern KeycodeKP0,
        pattern KeycodeKPPeriod,
        pattern KeycodeApplication,
        pattern KeycodePower,
        pattern KeycodeKPEquals,
        pattern KeycodeF13,
        pattern KeycodeF14,
        pattern KeycodeF15,
        pattern KeycodeF16,
        pattern KeycodeF17,
        pattern KeycodeF18,
        pattern KeycodeF19,
        pattern KeycodeF20,
        pattern KeycodeF21,
        pattern KeycodeF22,
        pattern KeycodeF23,
        pattern KeycodeF24,
        pattern KeycodeExecute,
        pattern KeycodeHelp,
        pattern KeycodeMenu,
        pattern KeycodeSelect,
        pattern KeycodeStop,
        pattern KeycodeAgain,
        pattern KeycodeUndo,
        pattern KeycodeCut,
        pattern KeycodeCopy,
        pattern KeycodePaste,
        pattern KeycodeFind,
        pattern KeycodeMute,
        pattern KeycodeVolumeUp,
        pattern KeycodeVolumeDown,
        pattern KeycodeKPComma,
        pattern KeycodeKPEqualsAS400,
        pattern KeycodeAltErase,
        pattern KeycodeSysReq,
        pattern KeycodeCancel,
        pattern KeycodeClear,
        pattern KeycodePrior,
        pattern KeycodeReturn2,
        pattern KeycodeSeparator,
        pattern KeycodeOut,
        pattern KeycodeOper,
        pattern KeycodeClearAgain,
        pattern KeycodeCrSel,
        pattern KeycodeExSel,
        pattern KeycodeKP00,
        pattern KeycodeKP000,
        pattern KeycodeThousandsSeparator,
        pattern KeycodeDecimalSeparator,
        pattern KeycodeCurrencyUnit,
        pattern KeycodeCurrencySubunit,
        pattern KeycodeKPLeftParen,
        pattern KeycodeKPRightParen,
        pattern KeycodeKPLeftBrace,
        pattern KeycodeKPRightBrace,
        pattern KeycodeKPTab,
        pattern KeycodeKPBackspace,
        pattern KeycodeKPA,
        pattern KeycodeKPB,
        pattern KeycodeKPC,
        pattern KeycodeKPD,
        pattern KeycodeKPE,
        pattern KeycodeKPF,
        pattern KeycodeKPXor,
        pattern KeycodeKPPower,
        pattern KeycodeKPPercent,
        pattern KeycodeKPLess,
        pattern KeycodeKPGreater,
        pattern KeycodeKPAmpersand,
        pattern KeycodeKPDblAmpersand,
        pattern KeycodeKPVerticalBar,
        pattern KeycodeKPDblVerticalBar,
        pattern KeycodeKPColon,
        pattern KeycodeKPHash,
        pattern KeycodeKPSpace,
        pattern KeycodeKPAt,
        pattern KeycodeKPExclam,
        pattern KeycodeKPMemStore,
        pattern KeycodeKPMemRecall,
        pattern KeycodeKPMemClear,
        pattern KeycodeKPMemAdd,
        pattern KeycodeKPMemSubtract,
        pattern KeycodeKPMemMultiply,
        pattern KeycodeKPMemDivide,
        pattern KeycodeKPPlusMinus,
        pattern KeycodeKPClear,
        pattern KeycodeKPClearEntry,
        pattern KeycodeKPBinary,
        pattern KeycodeKPOctal,
        pattern KeycodeKPDecimal,
        pattern KeycodeKPHexadecimal,
        pattern KeycodeLCtrl,
        pattern KeycodeLShift,
        pattern KeycodeLAlt,
        pattern KeycodeLGUI,
        pattern KeycodeRCtrl,
        pattern KeycodeRShift,
        pattern KeycodeRAlt,
        pattern KeycodeRGUI,
        pattern KeycodeMode,
        pattern KeycodeAudioNext,
        pattern KeycodeAudioPrev,
        pattern KeycodeAudioStop,
        pattern KeycodeAudioPlay,
        pattern KeycodeAudioMute,
        pattern KeycodeMediaSelect,
        pattern KeycodeWWW,
        pattern KeycodeMail,
        pattern KeycodeCalculator,
        pattern KeycodeComputer,
        pattern KeycodeACSearch,
        pattern KeycodeACHome,
        pattern KeycodeACBack,
        pattern KeycodeACForward,
        pattern KeycodeACStop,
        pattern KeycodeACRefresh,
        pattern KeycodeACBookmarks,
        pattern KeycodeBrightnessDown,
        pattern KeycodeBrightnessUp,
        pattern KeycodeDisplaySwitch,
        pattern KeycodeKbdIllumToggle,
        pattern KeycodeKbdIllumDown,
        pattern KeycodeKbdIllumUp,
        pattern KeycodeEject,
        pattern KeycodeSleep)

       where

import GHC.Generics (Generic)
import Data.Data (Data)
import Data.Int
import Data.Typeable
import Data.Word
import SDL.Internal.Numbered
import qualified SDL.Raw.Enum as Raw

newtype Scancode = Scancode { Scancode -> Word32
unwrapScancode :: Word32 }
  deriving (Scancode
Scancode -> Scancode -> Bounded Scancode
forall a. a -> a -> Bounded a
$cminBound :: Scancode
minBound :: Scancode
$cmaxBound :: Scancode
maxBound :: Scancode
Bounded, Typeable Scancode
Typeable Scancode =>
(forall (c :: Type -> Type).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Scancode -> c Scancode)
-> (forall (c :: Type -> Type).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Scancode)
-> (Scancode -> Constr)
-> (Scancode -> DataType)
-> (forall (t :: Type -> Type) (c :: Type -> Type).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Scancode))
-> (forall (t :: Type -> Type -> Type) (c :: Type -> Type).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Scancode))
-> ((forall b. Data b => b -> b) -> Scancode -> Scancode)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Scancode -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Scancode -> r)
-> (forall u. (forall d. Data d => d -> u) -> Scancode -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Scancode -> u)
-> (forall (m :: Type -> Type).
    Monad m =>
    (forall d. Data d => d -> m d) -> Scancode -> m Scancode)
-> (forall (m :: Type -> Type).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Scancode -> m Scancode)
-> (forall (m :: Type -> Type).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Scancode -> m Scancode)
-> Data Scancode
Scancode -> Constr
Scancode -> DataType
(forall b. Data b => b -> b) -> Scancode -> Scancode
forall a.
Typeable a =>
(forall (c :: Type -> Type).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: Type -> Type).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: Type -> Type) (c :: Type -> Type).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: Type -> Type -> Type) (c :: Type -> Type).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: Type -> Type).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: Type -> Type).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: Type -> Type).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Scancode -> u
forall u. (forall d. Data d => d -> u) -> Scancode -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Scancode -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Scancode -> r
forall (m :: Type -> Type).
Monad m =>
(forall d. Data d => d -> m d) -> Scancode -> m Scancode
forall (m :: Type -> Type).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Scancode -> m Scancode
forall (c :: Type -> Type).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Scancode
forall (c :: Type -> Type).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Scancode -> c Scancode
forall (t :: Type -> Type) (c :: Type -> Type).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Scancode)
forall (t :: Type -> Type -> Type) (c :: Type -> Type).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Scancode)
$cgfoldl :: forall (c :: Type -> Type).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Scancode -> c Scancode
gfoldl :: forall (c :: Type -> Type).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Scancode -> c Scancode
$cgunfold :: forall (c :: Type -> Type).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Scancode
gunfold :: forall (c :: Type -> Type).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Scancode
$ctoConstr :: Scancode -> Constr
toConstr :: Scancode -> Constr
$cdataTypeOf :: Scancode -> DataType
dataTypeOf :: Scancode -> DataType
$cdataCast1 :: forall (t :: Type -> Type) (c :: Type -> Type).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Scancode)
dataCast1 :: forall (t :: Type -> Type) (c :: Type -> Type).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Scancode)
$cdataCast2 :: forall (t :: Type -> Type -> Type) (c :: Type -> Type).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Scancode)
dataCast2 :: forall (t :: Type -> Type -> Type) (c :: Type -> Type).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Scancode)
$cgmapT :: (forall b. Data b => b -> b) -> Scancode -> Scancode
gmapT :: (forall b. Data b => b -> b) -> Scancode -> Scancode
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Scancode -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Scancode -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Scancode -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Scancode -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Scancode -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Scancode -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Scancode -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Scancode -> u
$cgmapM :: forall (m :: Type -> Type).
Monad m =>
(forall d. Data d => d -> m d) -> Scancode -> m Scancode
gmapM :: forall (m :: Type -> Type).
Monad m =>
(forall d. Data d => d -> m d) -> Scancode -> m Scancode
$cgmapMp :: forall (m :: Type -> Type).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Scancode -> m Scancode
gmapMp :: forall (m :: Type -> Type).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Scancode -> m Scancode
$cgmapMo :: forall (m :: Type -> Type).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Scancode -> m Scancode
gmapMo :: forall (m :: Type -> Type).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Scancode -> m Scancode
Data, Scancode -> Scancode -> Bool
(Scancode -> Scancode -> Bool)
-> (Scancode -> Scancode -> Bool) -> Eq Scancode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Scancode -> Scancode -> Bool
== :: Scancode -> Scancode -> Bool
$c/= :: Scancode -> Scancode -> Bool
/= :: Scancode -> Scancode -> Bool
Eq, Eq Scancode
Eq Scancode =>
(Scancode -> Scancode -> Ordering)
-> (Scancode -> Scancode -> Bool)
-> (Scancode -> Scancode -> Bool)
-> (Scancode -> Scancode -> Bool)
-> (Scancode -> Scancode -> Bool)
-> (Scancode -> Scancode -> Scancode)
-> (Scancode -> Scancode -> Scancode)
-> Ord Scancode
Scancode -> Scancode -> Bool
Scancode -> Scancode -> Ordering
Scancode -> Scancode -> Scancode
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Scancode -> Scancode -> Ordering
compare :: Scancode -> Scancode -> Ordering
$c< :: Scancode -> Scancode -> Bool
< :: Scancode -> Scancode -> Bool
$c<= :: Scancode -> Scancode -> Bool
<= :: Scancode -> Scancode -> Bool
$c> :: Scancode -> Scancode -> Bool
> :: Scancode -> Scancode -> Bool
$c>= :: Scancode -> Scancode -> Bool
>= :: Scancode -> Scancode -> Bool
$cmax :: Scancode -> Scancode -> Scancode
max :: Scancode -> Scancode -> Scancode
$cmin :: Scancode -> Scancode -> Scancode
min :: Scancode -> Scancode -> Scancode
Ord, ReadPrec [Scancode]
ReadPrec Scancode
Int -> ReadS Scancode
ReadS [Scancode]
(Int -> ReadS Scancode)
-> ReadS [Scancode]
-> ReadPrec Scancode
-> ReadPrec [Scancode]
-> Read Scancode
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Scancode
readsPrec :: Int -> ReadS Scancode
$creadList :: ReadS [Scancode]
readList :: ReadS [Scancode]
$creadPrec :: ReadPrec Scancode
readPrec :: ReadPrec Scancode
$creadListPrec :: ReadPrec [Scancode]
readListPrec :: ReadPrec [Scancode]
Read, (forall x. Scancode -> Rep Scancode x)
-> (forall x. Rep Scancode x -> Scancode) -> Generic Scancode
forall x. Rep Scancode x -> Scancode
forall x. Scancode -> Rep Scancode x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Scancode -> Rep Scancode x
from :: forall x. Scancode -> Rep Scancode x
$cto :: forall x. Rep Scancode x -> Scancode
to :: forall x. Rep Scancode x -> Scancode
Generic, Int -> Scancode -> ShowS
[Scancode] -> ShowS
Scancode -> String
(Int -> Scancode -> ShowS)
-> (Scancode -> String) -> ([Scancode] -> ShowS) -> Show Scancode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Scancode -> ShowS
showsPrec :: Int -> Scancode -> ShowS
$cshow :: Scancode -> String
show :: Scancode -> String
$cshowList :: [Scancode] -> ShowS
showList :: [Scancode] -> ShowS
Show, Typeable)

pattern $mScancodeUnknown :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeUnknown :: Scancode
ScancodeUnknown = Scancode Raw.SDL_SCANCODE_UNKNOWN
pattern $mScancodeA :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeA :: Scancode
ScancodeA = Scancode Raw.SDL_SCANCODE_A
pattern $mScancodeB :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeB :: Scancode
ScancodeB = Scancode Raw.SDL_SCANCODE_B
pattern $mScancodeC :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeC :: Scancode
ScancodeC = Scancode Raw.SDL_SCANCODE_C
pattern $mScancodeD :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeD :: Scancode
ScancodeD = Scancode Raw.SDL_SCANCODE_D
pattern $mScancodeE :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeE :: Scancode
ScancodeE = Scancode Raw.SDL_SCANCODE_E
pattern $mScancodeF :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeF :: Scancode
ScancodeF = Scancode Raw.SDL_SCANCODE_F
pattern $mScancodeG :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeG :: Scancode
ScancodeG = Scancode Raw.SDL_SCANCODE_G
pattern $mScancodeH :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeH :: Scancode
ScancodeH = Scancode Raw.SDL_SCANCODE_H
pattern $mScancodeI :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeI :: Scancode
ScancodeI = Scancode Raw.SDL_SCANCODE_I
pattern $mScancodeJ :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeJ :: Scancode
ScancodeJ = Scancode Raw.SDL_SCANCODE_J
pattern $mScancodeK :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeK :: Scancode
ScancodeK = Scancode Raw.SDL_SCANCODE_K
pattern $mScancodeL :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeL :: Scancode
ScancodeL = Scancode Raw.SDL_SCANCODE_L
pattern $mScancodeM :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeM :: Scancode
ScancodeM = Scancode Raw.SDL_SCANCODE_M
pattern $mScancodeN :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeN :: Scancode
ScancodeN = Scancode Raw.SDL_SCANCODE_N
pattern $mScancodeO :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeO :: Scancode
ScancodeO = Scancode Raw.SDL_SCANCODE_O
pattern $mScancodeP :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeP :: Scancode
ScancodeP = Scancode Raw.SDL_SCANCODE_P
pattern $mScancodeQ :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeQ :: Scancode
ScancodeQ = Scancode Raw.SDL_SCANCODE_Q
pattern $mScancodeR :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeR :: Scancode
ScancodeR = Scancode Raw.SDL_SCANCODE_R
pattern $mScancodeS :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeS :: Scancode
ScancodeS = Scancode Raw.SDL_SCANCODE_S
pattern $mScancodeT :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeT :: Scancode
ScancodeT = Scancode Raw.SDL_SCANCODE_T
pattern $mScancodeU :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeU :: Scancode
ScancodeU = Scancode Raw.SDL_SCANCODE_U
pattern $mScancodeV :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeV :: Scancode
ScancodeV = Scancode Raw.SDL_SCANCODE_V
pattern $mScancodeW :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeW :: Scancode
ScancodeW = Scancode Raw.SDL_SCANCODE_W
pattern $mScancodeX :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeX :: Scancode
ScancodeX = Scancode Raw.SDL_SCANCODE_X
pattern $mScancodeY :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeY :: Scancode
ScancodeY = Scancode Raw.SDL_SCANCODE_Y
pattern $mScancodeZ :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeZ :: Scancode
ScancodeZ = Scancode Raw.SDL_SCANCODE_Z
pattern $mScancode1 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancode1 :: Scancode
Scancode1 = Scancode Raw.SDL_SCANCODE_1
pattern $mScancode2 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancode2 :: Scancode
Scancode2 = Scancode Raw.SDL_SCANCODE_2
pattern $mScancode3 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancode3 :: Scancode
Scancode3 = Scancode Raw.SDL_SCANCODE_3
pattern $mScancode4 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancode4 :: Scancode
Scancode4 = Scancode Raw.SDL_SCANCODE_4
pattern $mScancode5 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancode5 :: Scancode
Scancode5 = Scancode Raw.SDL_SCANCODE_5
pattern $mScancode6 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancode6 :: Scancode
Scancode6 = Scancode Raw.SDL_SCANCODE_6
pattern $mScancode7 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancode7 :: Scancode
Scancode7 = Scancode Raw.SDL_SCANCODE_7
pattern $mScancode8 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancode8 :: Scancode
Scancode8 = Scancode Raw.SDL_SCANCODE_8
pattern $mScancode9 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancode9 :: Scancode
Scancode9 = Scancode Raw.SDL_SCANCODE_9
pattern $mScancode0 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancode0 :: Scancode
Scancode0 = Scancode Raw.SDL_SCANCODE_0
pattern $mScancodeReturn :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeReturn :: Scancode
ScancodeReturn = Scancode Raw.SDL_SCANCODE_RETURN
pattern $mScancodeEscape :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeEscape :: Scancode
ScancodeEscape = Scancode Raw.SDL_SCANCODE_ESCAPE
pattern $mScancodeBackspace :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeBackspace :: Scancode
ScancodeBackspace = Scancode Raw.SDL_SCANCODE_BACKSPACE
pattern $mScancodeTab :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeTab :: Scancode
ScancodeTab = Scancode Raw.SDL_SCANCODE_TAB
pattern $mScancodeSpace :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeSpace :: Scancode
ScancodeSpace = Scancode Raw.SDL_SCANCODE_SPACE
pattern $mScancodeMinus :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeMinus :: Scancode
ScancodeMinus = Scancode Raw.SDL_SCANCODE_MINUS
pattern $mScancodeEquals :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeEquals :: Scancode
ScancodeEquals = Scancode Raw.SDL_SCANCODE_EQUALS
pattern $mScancodeLeftBracket :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeLeftBracket :: Scancode
ScancodeLeftBracket = Scancode Raw.SDL_SCANCODE_LEFTBRACKET
pattern $mScancodeRightBracket :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeRightBracket :: Scancode
ScancodeRightBracket = Scancode Raw.SDL_SCANCODE_RIGHTBRACKET
pattern $mScancodeBackslash :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeBackslash :: Scancode
ScancodeBackslash = Scancode Raw.SDL_SCANCODE_BACKSLASH
pattern $mScancodeNonUSHash :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeNonUSHash :: Scancode
ScancodeNonUSHash = Scancode Raw.SDL_SCANCODE_NONUSHASH
pattern $mScancodeSemicolon :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeSemicolon :: Scancode
ScancodeSemicolon = Scancode Raw.SDL_SCANCODE_SEMICOLON
pattern $mScancodeApostrophe :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeApostrophe :: Scancode
ScancodeApostrophe = Scancode Raw.SDL_SCANCODE_APOSTROPHE
pattern $mScancodeGrave :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeGrave :: Scancode
ScancodeGrave = Scancode Raw.SDL_SCANCODE_GRAVE
pattern $mScancodeComma :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeComma :: Scancode
ScancodeComma = Scancode Raw.SDL_SCANCODE_COMMA
pattern $mScancodePeriod :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodePeriod :: Scancode
ScancodePeriod = Scancode Raw.SDL_SCANCODE_PERIOD
pattern $mScancodeSlash :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeSlash :: Scancode
ScancodeSlash = Scancode Raw.SDL_SCANCODE_SLASH
pattern $mScancodeCapsLock :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeCapsLock :: Scancode
ScancodeCapsLock = Scancode Raw.SDL_SCANCODE_CAPSLOCK
pattern $mScancodeF1 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeF1 :: Scancode
ScancodeF1 = Scancode Raw.SDL_SCANCODE_F1
pattern $mScancodeF2 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeF2 :: Scancode
ScancodeF2 = Scancode Raw.SDL_SCANCODE_F2
pattern $mScancodeF3 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeF3 :: Scancode
ScancodeF3 = Scancode Raw.SDL_SCANCODE_F3
pattern $mScancodeF4 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeF4 :: Scancode
ScancodeF4 = Scancode Raw.SDL_SCANCODE_F4
pattern $mScancodeF5 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeF5 :: Scancode
ScancodeF5 = Scancode Raw.SDL_SCANCODE_F5
pattern $mScancodeF6 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeF6 :: Scancode
ScancodeF6 = Scancode Raw.SDL_SCANCODE_F6
pattern $mScancodeF7 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeF7 :: Scancode
ScancodeF7 = Scancode Raw.SDL_SCANCODE_F7
pattern $mScancodeF8 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeF8 :: Scancode
ScancodeF8 = Scancode Raw.SDL_SCANCODE_F8
pattern $mScancodeF9 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeF9 :: Scancode
ScancodeF9 = Scancode Raw.SDL_SCANCODE_F9
pattern $mScancodeF10 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeF10 :: Scancode
ScancodeF10 = Scancode Raw.SDL_SCANCODE_F10
pattern $mScancodeF11 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeF11 :: Scancode
ScancodeF11 = Scancode Raw.SDL_SCANCODE_F11
pattern $mScancodeF12 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeF12 :: Scancode
ScancodeF12 = Scancode Raw.SDL_SCANCODE_F12
pattern $mScancodePrintScreen :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodePrintScreen :: Scancode
ScancodePrintScreen = Scancode Raw.SDL_SCANCODE_PRINTSCREEN
pattern $mScancodeScrollLock :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeScrollLock :: Scancode
ScancodeScrollLock = Scancode Raw.SDL_SCANCODE_SCROLLLOCK
pattern $mScancodePause :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodePause :: Scancode
ScancodePause = Scancode Raw.SDL_SCANCODE_PAUSE
pattern $mScancodeInsert :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeInsert :: Scancode
ScancodeInsert = Scancode Raw.SDL_SCANCODE_INSERT
pattern $mScancodeHome :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeHome :: Scancode
ScancodeHome = Scancode Raw.SDL_SCANCODE_HOME
pattern $mScancodePageUp :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodePageUp :: Scancode
ScancodePageUp = Scancode Raw.SDL_SCANCODE_PAGEUP
pattern $mScancodeDelete :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeDelete :: Scancode
ScancodeDelete = Scancode Raw.SDL_SCANCODE_DELETE
pattern $mScancodeEnd :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeEnd :: Scancode
ScancodeEnd = Scancode Raw.SDL_SCANCODE_END
pattern $mScancodePageDown :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodePageDown :: Scancode
ScancodePageDown = Scancode Raw.SDL_SCANCODE_PAGEDOWN
pattern $mScancodeRight :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeRight :: Scancode
ScancodeRight = Scancode Raw.SDL_SCANCODE_RIGHT
pattern $mScancodeLeft :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeLeft :: Scancode
ScancodeLeft = Scancode Raw.SDL_SCANCODE_LEFT
pattern $mScancodeDown :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeDown :: Scancode
ScancodeDown = Scancode Raw.SDL_SCANCODE_DOWN
pattern $mScancodeUp :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeUp :: Scancode
ScancodeUp = Scancode Raw.SDL_SCANCODE_UP
pattern $mScancodeNumLockClear :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeNumLockClear :: Scancode
ScancodeNumLockClear = Scancode Raw.SDL_SCANCODE_NUMLOCKCLEAR
pattern $mScancodeKPDivide :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeKPDivide :: Scancode
ScancodeKPDivide = Scancode Raw.SDL_SCANCODE_KP_DIVIDE
pattern $mScancodeKPMultiply :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeKPMultiply :: Scancode
ScancodeKPMultiply = Scancode Raw.SDL_SCANCODE_KP_MULTIPLY
pattern $mScancodeKPMinus :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeKPMinus :: Scancode
ScancodeKPMinus = Scancode Raw.SDL_SCANCODE_KP_MINUS
pattern $mScancodeKPPlus :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeKPPlus :: Scancode
ScancodeKPPlus = Scancode Raw.SDL_SCANCODE_KP_PLUS
pattern $mScancodeKPEnter :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeKPEnter :: Scancode
ScancodeKPEnter = Scancode Raw.SDL_SCANCODE_KP_ENTER
pattern $mScancodeKP1 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeKP1 :: Scancode
ScancodeKP1 = Scancode Raw.SDL_SCANCODE_KP_1
pattern $mScancodeKP2 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeKP2 :: Scancode
ScancodeKP2 = Scancode Raw.SDL_SCANCODE_KP_2
pattern $mScancodeKP3 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeKP3 :: Scancode
ScancodeKP3 = Scancode Raw.SDL_SCANCODE_KP_3
pattern $mScancodeKP4 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeKP4 :: Scancode
ScancodeKP4 = Scancode Raw.SDL_SCANCODE_KP_4
pattern $mScancodeKP5 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeKP5 :: Scancode
ScancodeKP5 = Scancode Raw.SDL_SCANCODE_KP_5
pattern $mScancodeKP6 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeKP6 :: Scancode
ScancodeKP6 = Scancode Raw.SDL_SCANCODE_KP_6
pattern $mScancodeKP7 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeKP7 :: Scancode
ScancodeKP7 = Scancode Raw.SDL_SCANCODE_KP_7
pattern $mScancodeKP8 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeKP8 :: Scancode
ScancodeKP8 = Scancode Raw.SDL_SCANCODE_KP_8
pattern $mScancodeKP9 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeKP9 :: Scancode
ScancodeKP9 = Scancode Raw.SDL_SCANCODE_KP_9
pattern $mScancodeKP0 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeKP0 :: Scancode
ScancodeKP0 = Scancode Raw.SDL_SCANCODE_KP_0
pattern $mScancodeKPPeriod :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeKPPeriod :: Scancode
ScancodeKPPeriod = Scancode Raw.SDL_SCANCODE_KP_PERIOD
pattern $mScancodeNonUSBackslash :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeNonUSBackslash :: Scancode
ScancodeNonUSBackslash = Scancode Raw.SDL_SCANCODE_NONUSBACKSLASH
pattern $mScancodeApplication :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeApplication :: Scancode
ScancodeApplication = Scancode Raw.SDL_SCANCODE_APPLICATION
pattern $mScancodePower :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodePower :: Scancode
ScancodePower = Scancode Raw.SDL_SCANCODE_POWER
pattern $mScancodeKPEquals :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeKPEquals :: Scancode
ScancodeKPEquals = Scancode Raw.SDL_SCANCODE_KP_EQUALS
pattern $mScancodeF13 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeF13 :: Scancode
ScancodeF13 = Scancode Raw.SDL_SCANCODE_F13
pattern $mScancodeF14 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeF14 :: Scancode
ScancodeF14 = Scancode Raw.SDL_SCANCODE_F14
pattern $mScancodeF15 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeF15 :: Scancode
ScancodeF15 = Scancode Raw.SDL_SCANCODE_F15
pattern $mScancodeF16 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeF16 :: Scancode
ScancodeF16 = Scancode Raw.SDL_SCANCODE_F16
pattern $mScancodeF17 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeF17 :: Scancode
ScancodeF17 = Scancode Raw.SDL_SCANCODE_F17
pattern $mScancodeF18 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeF18 :: Scancode
ScancodeF18 = Scancode Raw.SDL_SCANCODE_F18
pattern $mScancodeF19 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeF19 :: Scancode
ScancodeF19 = Scancode Raw.SDL_SCANCODE_F19
pattern $mScancodeF20 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeF20 :: Scancode
ScancodeF20 = Scancode Raw.SDL_SCANCODE_F20
pattern $mScancodeF21 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeF21 :: Scancode
ScancodeF21 = Scancode Raw.SDL_SCANCODE_F21
pattern $mScancodeF22 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeF22 :: Scancode
ScancodeF22 = Scancode Raw.SDL_SCANCODE_F22
pattern $mScancodeF23 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeF23 :: Scancode
ScancodeF23 = Scancode Raw.SDL_SCANCODE_F23
pattern $mScancodeF24 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeF24 :: Scancode
ScancodeF24 = Scancode Raw.SDL_SCANCODE_F24
pattern $mScancodeExecute :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeExecute :: Scancode
ScancodeExecute = Scancode Raw.SDL_SCANCODE_EXECUTE
pattern $mScancodeHelp :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeHelp :: Scancode
ScancodeHelp = Scancode Raw.SDL_SCANCODE_HELP
pattern $mScancodeMenu :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeMenu :: Scancode
ScancodeMenu = Scancode Raw.SDL_SCANCODE_MENU
pattern $mScancodeSelect :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeSelect :: Scancode
ScancodeSelect = Scancode Raw.SDL_SCANCODE_SELECT
pattern $mScancodeStop :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeStop :: Scancode
ScancodeStop = Scancode Raw.SDL_SCANCODE_STOP
pattern $mScancodeAgain :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeAgain :: Scancode
ScancodeAgain = Scancode Raw.SDL_SCANCODE_AGAIN
pattern $mScancodeUndo :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeUndo :: Scancode
ScancodeUndo = Scancode Raw.SDL_SCANCODE_UNDO
pattern $mScancodeCut :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeCut :: Scancode
ScancodeCut = Scancode Raw.SDL_SCANCODE_CUT
pattern $mScancodeCopy :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeCopy :: Scancode
ScancodeCopy = Scancode Raw.SDL_SCANCODE_COPY
pattern $mScancodePaste :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodePaste :: Scancode
ScancodePaste = Scancode Raw.SDL_SCANCODE_PASTE
pattern $mScancodeFind :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeFind :: Scancode
ScancodeFind = Scancode Raw.SDL_SCANCODE_FIND
pattern $mScancodeMute :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeMute :: Scancode
ScancodeMute = Scancode Raw.SDL_SCANCODE_MUTE
pattern $mScancodeVolumeUp :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeVolumeUp :: Scancode
ScancodeVolumeUp = Scancode Raw.SDL_SCANCODE_VOLUMEUP
pattern $mScancodeVolumeDown :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeVolumeDown :: Scancode
ScancodeVolumeDown = Scancode Raw.SDL_SCANCODE_VOLUMEDOWN
pattern $mScancodeKPComma :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeKPComma :: Scancode
ScancodeKPComma = Scancode Raw.SDL_SCANCODE_KP_COMMA
pattern $mScancodeKPEqualsAS400 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeKPEqualsAS400 :: Scancode
ScancodeKPEqualsAS400 = Scancode Raw.SDL_SCANCODE_KP_EQUALSAS400
pattern $mScancodeInternational1 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeInternational1 :: Scancode
ScancodeInternational1 = Scancode Raw.SDL_SCANCODE_INTERNATIONAL1
pattern $mScancodeInternational2 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeInternational2 :: Scancode
ScancodeInternational2 = Scancode Raw.SDL_SCANCODE_INTERNATIONAL2
pattern $mScancodeInternational3 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeInternational3 :: Scancode
ScancodeInternational3 = Scancode Raw.SDL_SCANCODE_INTERNATIONAL3
pattern $mScancodeInternational4 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeInternational4 :: Scancode
ScancodeInternational4 = Scancode Raw.SDL_SCANCODE_INTERNATIONAL4
pattern $mScancodeInternational5 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeInternational5 :: Scancode
ScancodeInternational5 = Scancode Raw.SDL_SCANCODE_INTERNATIONAL5
pattern $mScancodeInternational6 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeInternational6 :: Scancode
ScancodeInternational6 = Scancode Raw.SDL_SCANCODE_INTERNATIONAL6
pattern $mScancodeInternational7 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeInternational7 :: Scancode
ScancodeInternational7 = Scancode Raw.SDL_SCANCODE_INTERNATIONAL7
pattern $mScancodeInternational8 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeInternational8 :: Scancode
ScancodeInternational8 = Scancode Raw.SDL_SCANCODE_INTERNATIONAL8
pattern $mScancodeInternational9 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeInternational9 :: Scancode
ScancodeInternational9 = Scancode Raw.SDL_SCANCODE_INTERNATIONAL9
pattern $mScancodeLang1 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeLang1 :: Scancode
ScancodeLang1 = Scancode Raw.SDL_SCANCODE_LANG1
pattern $mScancodeLang2 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeLang2 :: Scancode
ScancodeLang2 = Scancode Raw.SDL_SCANCODE_LANG2
pattern $mScancodeLang3 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeLang3 :: Scancode
ScancodeLang3 = Scancode Raw.SDL_SCANCODE_LANG3
pattern $mScancodeLang4 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeLang4 :: Scancode
ScancodeLang4 = Scancode Raw.SDL_SCANCODE_LANG4
pattern $mScancodeLang5 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeLang5 :: Scancode
ScancodeLang5 = Scancode Raw.SDL_SCANCODE_LANG5
pattern $mScancodeLang6 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeLang6 :: Scancode
ScancodeLang6 = Scancode Raw.SDL_SCANCODE_LANG6
pattern $mScancodeLang7 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeLang7 :: Scancode
ScancodeLang7 = Scancode Raw.SDL_SCANCODE_LANG7
pattern $mScancodeLang8 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeLang8 :: Scancode
ScancodeLang8 = Scancode Raw.SDL_SCANCODE_LANG8
pattern $mScancodeLang9 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeLang9 :: Scancode
ScancodeLang9 = Scancode Raw.SDL_SCANCODE_LANG9
pattern $mScancodeAltErase :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeAltErase :: Scancode
ScancodeAltErase = Scancode Raw.SDL_SCANCODE_ALTERASE
pattern $mScancodeSysReq :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeSysReq :: Scancode
ScancodeSysReq = Scancode Raw.SDL_SCANCODE_SYSREQ
pattern $mScancodeCancel :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeCancel :: Scancode
ScancodeCancel = Scancode Raw.SDL_SCANCODE_CANCEL
pattern $mScancodeClear :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeClear :: Scancode
ScancodeClear = Scancode Raw.SDL_SCANCODE_CLEAR
pattern $mScancodePrior :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodePrior :: Scancode
ScancodePrior = Scancode Raw.SDL_SCANCODE_PRIOR
pattern $mScancodeReturn2 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeReturn2 :: Scancode
ScancodeReturn2 = Scancode Raw.SDL_SCANCODE_RETURN2
pattern $mScancodeSeparator :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeSeparator :: Scancode
ScancodeSeparator = Scancode Raw.SDL_SCANCODE_SEPARATOR
pattern $mScancodeOut :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeOut :: Scancode
ScancodeOut = Scancode Raw.SDL_SCANCODE_OUT
pattern $mScancodeOper :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeOper :: Scancode
ScancodeOper = Scancode Raw.SDL_SCANCODE_OPER
pattern $mScancodeClearAgain :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeClearAgain :: Scancode
ScancodeClearAgain = Scancode Raw.SDL_SCANCODE_CLEARAGAIN
pattern $mScancodeCrSel :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeCrSel :: Scancode
ScancodeCrSel = Scancode Raw.SDL_SCANCODE_CRSEL
pattern $mScancodeExSel :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeExSel :: Scancode
ScancodeExSel = Scancode Raw.SDL_SCANCODE_EXSEL
pattern $mScancodeKP00 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeKP00 :: Scancode
ScancodeKP00 = Scancode Raw.SDL_SCANCODE_KP_00
pattern $mScancodeKP000 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeKP000 :: Scancode
ScancodeKP000 = Scancode Raw.SDL_SCANCODE_KP_000
pattern $mScancodeThousandsSeparator :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeThousandsSeparator :: Scancode
ScancodeThousandsSeparator = Scancode Raw.SDL_SCANCODE_THOUSANDSSEPARATOR
pattern $mScancodeDecimalSeparator :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeDecimalSeparator :: Scancode
ScancodeDecimalSeparator = Scancode Raw.SDL_SCANCODE_DECIMALSEPARATOR
pattern $mScancodeCurrencyUnit :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeCurrencyUnit :: Scancode
ScancodeCurrencyUnit = Scancode Raw.SDL_SCANCODE_CURRENCYUNIT
pattern $mScancodeCurrencySubunit :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeCurrencySubunit :: Scancode
ScancodeCurrencySubunit = Scancode Raw.SDL_SCANCODE_CURRENCYSUBUNIT
pattern $mScancodeLeftParen :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeLeftParen :: Scancode
ScancodeLeftParen = Scancode Raw.SDL_SCANCODE_KP_LEFTPAREN
pattern $mScancodeRightParen :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeRightParen :: Scancode
ScancodeRightParen = Scancode Raw.SDL_SCANCODE_KP_RIGHTPAREN
pattern $mScancodeLeftBrace :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeLeftBrace :: Scancode
ScancodeLeftBrace = Scancode Raw.SDL_SCANCODE_KP_LEFTBRACE
pattern $mScancodeRightBrace :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeRightBrace :: Scancode
ScancodeRightBrace = Scancode Raw.SDL_SCANCODE_KP_RIGHTBRACE
pattern $mScancodeKPTab :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeKPTab :: Scancode
ScancodeKPTab = Scancode Raw.SDL_SCANCODE_KP_TAB
pattern $mScancodeKPBackspace :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeKPBackspace :: Scancode
ScancodeKPBackspace = Scancode Raw.SDL_SCANCODE_KP_BACKSPACE
pattern $mScancodeKPA :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeKPA :: Scancode
ScancodeKPA = Scancode Raw.SDL_SCANCODE_KP_A
pattern $mScancodeKPB :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeKPB :: Scancode
ScancodeKPB = Scancode Raw.SDL_SCANCODE_KP_B
pattern $mScancodeKPC :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeKPC :: Scancode
ScancodeKPC = Scancode Raw.SDL_SCANCODE_KP_C
pattern $mScancodeKPD :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeKPD :: Scancode
ScancodeKPD = Scancode Raw.SDL_SCANCODE_KP_D
pattern $mScancodeKPE :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeKPE :: Scancode
ScancodeKPE = Scancode Raw.SDL_SCANCODE_KP_E
pattern $mScancodeKPF :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeKPF :: Scancode
ScancodeKPF = Scancode Raw.SDL_SCANCODE_KP_F
pattern $mScancodeKPXOR :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeKPXOR :: Scancode
ScancodeKPXOR = Scancode Raw.SDL_SCANCODE_KP_XOR
pattern $mScancodeKPPower :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeKPPower :: Scancode
ScancodeKPPower = Scancode Raw.SDL_SCANCODE_KP_POWER
pattern $mScancodeKPPercent :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeKPPercent :: Scancode
ScancodeKPPercent = Scancode Raw.SDL_SCANCODE_KP_PERCENT
pattern $mScancodeKPLess :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeKPLess :: Scancode
ScancodeKPLess = Scancode Raw.SDL_SCANCODE_KP_LESS
pattern $mScancodeKPGreater :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeKPGreater :: Scancode
ScancodeKPGreater = Scancode Raw.SDL_SCANCODE_KP_GREATER
pattern $mScancodeKPAmpersand :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeKPAmpersand :: Scancode
ScancodeKPAmpersand = Scancode Raw.SDL_SCANCODE_KP_AMPERSAND
pattern $mScancodeKPDblAmpersand :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeKPDblAmpersand :: Scancode
ScancodeKPDblAmpersand = Scancode Raw.SDL_SCANCODE_KP_DBLAMPERSAND
pattern $mScancodeKPVerticalBar :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeKPVerticalBar :: Scancode
ScancodeKPVerticalBar = Scancode Raw.SDL_SCANCODE_KP_VERTICALBAR
pattern $mScancodeKPDblVerticalBar :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeKPDblVerticalBar :: Scancode
ScancodeKPDblVerticalBar = Scancode Raw.SDL_SCANCODE_KP_DBLVERTICALBAR
pattern $mScancodeKPColon :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeKPColon :: Scancode
ScancodeKPColon = Scancode Raw.SDL_SCANCODE_KP_COLON
pattern $mScancodeKPHash :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeKPHash :: Scancode
ScancodeKPHash = Scancode Raw.SDL_SCANCODE_KP_HASH
pattern $mScancodeKPSpace :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeKPSpace :: Scancode
ScancodeKPSpace = Scancode Raw.SDL_SCANCODE_KP_SPACE
pattern $mScancodeKPAt :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeKPAt :: Scancode
ScancodeKPAt = Scancode Raw.SDL_SCANCODE_KP_AT
pattern $mScancodeKPExclam :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeKPExclam :: Scancode
ScancodeKPExclam = Scancode Raw.SDL_SCANCODE_KP_EXCLAM
pattern $mScancodeKPMemStore :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeKPMemStore :: Scancode
ScancodeKPMemStore = Scancode Raw.SDL_SCANCODE_KP_MEMSTORE
pattern $mScancodeKPMemRecall :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeKPMemRecall :: Scancode
ScancodeKPMemRecall = Scancode Raw.SDL_SCANCODE_KP_MEMRECALL
pattern $mScancodeKPMemClear :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeKPMemClear :: Scancode
ScancodeKPMemClear = Scancode Raw.SDL_SCANCODE_KP_MEMCLEAR
pattern $mScancodeKPMemAdd :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeKPMemAdd :: Scancode
ScancodeKPMemAdd = Scancode Raw.SDL_SCANCODE_KP_MEMADD
pattern $mScancodeKPMemSubtract :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeKPMemSubtract :: Scancode
ScancodeKPMemSubtract = Scancode Raw.SDL_SCANCODE_KP_MEMSUBTRACT
pattern $mScancodeKPMemMultiply :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeKPMemMultiply :: Scancode
ScancodeKPMemMultiply = Scancode Raw.SDL_SCANCODE_KP_MEMMULTIPLY
pattern $mScancodeKPMemDivide :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeKPMemDivide :: Scancode
ScancodeKPMemDivide = Scancode Raw.SDL_SCANCODE_KP_MEMDIVIDE
pattern $mScancodeKPPlusMinus :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeKPPlusMinus :: Scancode
ScancodeKPPlusMinus = Scancode Raw.SDL_SCANCODE_KP_PLUSMINUS
pattern $mScancodeKPClear :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeKPClear :: Scancode
ScancodeKPClear = Scancode Raw.SDL_SCANCODE_KP_CLEAR
pattern $mScancodeKPClearEntry :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeKPClearEntry :: Scancode
ScancodeKPClearEntry = Scancode Raw.SDL_SCANCODE_KP_CLEARENTRY
pattern $mScancodeKPBinary :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeKPBinary :: Scancode
ScancodeKPBinary = Scancode Raw.SDL_SCANCODE_KP_BINARY
pattern $mScancodeKPOctal :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeKPOctal :: Scancode
ScancodeKPOctal = Scancode Raw.SDL_SCANCODE_KP_OCTAL
pattern $mScancodeKPDecimal :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeKPDecimal :: Scancode
ScancodeKPDecimal = Scancode Raw.SDL_SCANCODE_KP_DECIMAL
pattern $mScancodeKPHexadecimal :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeKPHexadecimal :: Scancode
ScancodeKPHexadecimal = Scancode Raw.SDL_SCANCODE_KP_HEXADECIMAL
pattern $mScancodeLCtrl :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeLCtrl :: Scancode
ScancodeLCtrl = Scancode Raw.SDL_SCANCODE_LCTRL
pattern $mScancodeLShift :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeLShift :: Scancode
ScancodeLShift = Scancode Raw.SDL_SCANCODE_LSHIFT
pattern $mScancodeLAlt :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeLAlt :: Scancode
ScancodeLAlt = Scancode Raw.SDL_SCANCODE_LALT
pattern $mScancodeLGUI :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeLGUI :: Scancode
ScancodeLGUI = Scancode Raw.SDL_SCANCODE_LGUI
pattern $mScancodeRCtrl :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeRCtrl :: Scancode
ScancodeRCtrl = Scancode Raw.SDL_SCANCODE_RCTRL
pattern $mScancodeRShift :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeRShift :: Scancode
ScancodeRShift = Scancode Raw.SDL_SCANCODE_RSHIFT
pattern $mScancodeRAlt :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeRAlt :: Scancode
ScancodeRAlt = Scancode Raw.SDL_SCANCODE_RALT
pattern $mScancodeRGUI :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeRGUI :: Scancode
ScancodeRGUI = Scancode Raw.SDL_SCANCODE_RGUI
pattern $mScancodeMode :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeMode :: Scancode
ScancodeMode = Scancode Raw.SDL_SCANCODE_MODE
pattern $mScancodeAudioNext :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeAudioNext :: Scancode
ScancodeAudioNext = Scancode Raw.SDL_SCANCODE_AUDIONEXT
pattern $mScancodeAudioPrev :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeAudioPrev :: Scancode
ScancodeAudioPrev = Scancode Raw.SDL_SCANCODE_AUDIOPREV
pattern $mScancodeAudioStop :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeAudioStop :: Scancode
ScancodeAudioStop = Scancode Raw.SDL_SCANCODE_AUDIOSTOP
pattern $mScancodeAudioPlay :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeAudioPlay :: Scancode
ScancodeAudioPlay = Scancode Raw.SDL_SCANCODE_AUDIOPLAY
pattern $mScancodeAudioMute :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeAudioMute :: Scancode
ScancodeAudioMute = Scancode Raw.SDL_SCANCODE_AUDIOMUTE
pattern $mScancodeMediaSelect :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeMediaSelect :: Scancode
ScancodeMediaSelect = Scancode Raw.SDL_SCANCODE_MEDIASELECT
pattern $mScancodeWWW :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeWWW :: Scancode
ScancodeWWW = Scancode Raw.SDL_SCANCODE_WWW
pattern $mScancodeMail :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeMail :: Scancode
ScancodeMail = Scancode Raw.SDL_SCANCODE_MAIL
pattern $mScancodeCalculator :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeCalculator :: Scancode
ScancodeCalculator = Scancode Raw.SDL_SCANCODE_CALCULATOR
pattern $mScancodeComputer :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeComputer :: Scancode
ScancodeComputer = Scancode Raw.SDL_SCANCODE_COMPUTER
pattern $mScancodeACSearch :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeACSearch :: Scancode
ScancodeACSearch = Scancode Raw.SDL_SCANCODE_AC_SEARCH
pattern $mScancodeACHome :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeACHome :: Scancode
ScancodeACHome = Scancode Raw.SDL_SCANCODE_AC_HOME
pattern $mScancodeACBack :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeACBack :: Scancode
ScancodeACBack = Scancode Raw.SDL_SCANCODE_AC_BACK
pattern $mScancodeACForward :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeACForward :: Scancode
ScancodeACForward = Scancode Raw.SDL_SCANCODE_AC_FORWARD
pattern $mScancodeACStop :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeACStop :: Scancode
ScancodeACStop = Scancode Raw.SDL_SCANCODE_AC_STOP
pattern $mScancodeACRefresh :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeACRefresh :: Scancode
ScancodeACRefresh = Scancode Raw.SDL_SCANCODE_AC_REFRESH
pattern $mScancodeACBookmarks :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeACBookmarks :: Scancode
ScancodeACBookmarks = Scancode Raw.SDL_SCANCODE_AC_BOOKMARKS
pattern $mScancodeBrightnessDown :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeBrightnessDown :: Scancode
ScancodeBrightnessDown = Scancode Raw.SDL_SCANCODE_BRIGHTNESSDOWN
pattern $mScancodeBrightnessUp :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeBrightnessUp :: Scancode
ScancodeBrightnessUp = Scancode Raw.SDL_SCANCODE_BRIGHTNESSUP
pattern $mScancodeDisplaySwitch :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeDisplaySwitch :: Scancode
ScancodeDisplaySwitch = Scancode Raw.SDL_SCANCODE_DISPLAYSWITCH
pattern $mScancodeKBDIllumToggle :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeKBDIllumToggle :: Scancode
ScancodeKBDIllumToggle = Scancode Raw.SDL_SCANCODE_KBDILLUMTOGGLE
pattern $mScancodeKBDIllumDown :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeKBDIllumDown :: Scancode
ScancodeKBDIllumDown = Scancode Raw.SDL_SCANCODE_KBDILLUMDOWN
pattern $mScancodeKBDIllumUp :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeKBDIllumUp :: Scancode
ScancodeKBDIllumUp = Scancode Raw.SDL_SCANCODE_KBDILLUMUP
pattern $mScancodeEject :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeEject :: Scancode
ScancodeEject = Scancode Raw.SDL_SCANCODE_EJECT
pattern $mScancodeSleep :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeSleep :: Scancode
ScancodeSleep = Scancode Raw.SDL_SCANCODE_SLEEP
pattern $mScancodeApp1 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeApp1 :: Scancode
ScancodeApp1 = Scancode Raw.SDL_SCANCODE_APP1
pattern $mScancodeApp2 :: forall {r}. Scancode -> ((# #) -> r) -> ((# #) -> r) -> r
$bScancodeApp2 :: Scancode
ScancodeApp2 = Scancode Raw.SDL_SCANCODE_APP2

instance FromNumber Scancode Word32 where
  fromNumber :: Word32 -> Scancode
fromNumber = Word32 -> Scancode
Scancode

instance ToNumber Scancode Word32 where
  toNumber :: Scancode -> Word32
toNumber = Scancode -> Word32
unwrapScancode

newtype Keycode = Keycode { Keycode -> Int32
unwrapKeycode :: Int32 }
  deriving (Keycode
Keycode -> Keycode -> Bounded Keycode
forall a. a -> a -> Bounded a
$cminBound :: Keycode
minBound :: Keycode
$cmaxBound :: Keycode
maxBound :: Keycode
Bounded, Typeable Keycode
Typeable Keycode =>
(forall (c :: Type -> Type).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Keycode -> c Keycode)
-> (forall (c :: Type -> Type).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Keycode)
-> (Keycode -> Constr)
-> (Keycode -> DataType)
-> (forall (t :: Type -> Type) (c :: Type -> Type).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Keycode))
-> (forall (t :: Type -> Type -> Type) (c :: Type -> Type).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Keycode))
-> ((forall b. Data b => b -> b) -> Keycode -> Keycode)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Keycode -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Keycode -> r)
-> (forall u. (forall d. Data d => d -> u) -> Keycode -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Keycode -> u)
-> (forall (m :: Type -> Type).
    Monad m =>
    (forall d. Data d => d -> m d) -> Keycode -> m Keycode)
-> (forall (m :: Type -> Type).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Keycode -> m Keycode)
-> (forall (m :: Type -> Type).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Keycode -> m Keycode)
-> Data Keycode
Keycode -> Constr
Keycode -> DataType
(forall b. Data b => b -> b) -> Keycode -> Keycode
forall a.
Typeable a =>
(forall (c :: Type -> Type).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: Type -> Type).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: Type -> Type) (c :: Type -> Type).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: Type -> Type -> Type) (c :: Type -> Type).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: Type -> Type).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: Type -> Type).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: Type -> Type).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Keycode -> u
forall u. (forall d. Data d => d -> u) -> Keycode -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Keycode -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Keycode -> r
forall (m :: Type -> Type).
Monad m =>
(forall d. Data d => d -> m d) -> Keycode -> m Keycode
forall (m :: Type -> Type).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Keycode -> m Keycode
forall (c :: Type -> Type).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Keycode
forall (c :: Type -> Type).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Keycode -> c Keycode
forall (t :: Type -> Type) (c :: Type -> Type).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Keycode)
forall (t :: Type -> Type -> Type) (c :: Type -> Type).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Keycode)
$cgfoldl :: forall (c :: Type -> Type).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Keycode -> c Keycode
gfoldl :: forall (c :: Type -> Type).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Keycode -> c Keycode
$cgunfold :: forall (c :: Type -> Type).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Keycode
gunfold :: forall (c :: Type -> Type).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Keycode
$ctoConstr :: Keycode -> Constr
toConstr :: Keycode -> Constr
$cdataTypeOf :: Keycode -> DataType
dataTypeOf :: Keycode -> DataType
$cdataCast1 :: forall (t :: Type -> Type) (c :: Type -> Type).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Keycode)
dataCast1 :: forall (t :: Type -> Type) (c :: Type -> Type).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Keycode)
$cdataCast2 :: forall (t :: Type -> Type -> Type) (c :: Type -> Type).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Keycode)
dataCast2 :: forall (t :: Type -> Type -> Type) (c :: Type -> Type).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Keycode)
$cgmapT :: (forall b. Data b => b -> b) -> Keycode -> Keycode
gmapT :: (forall b. Data b => b -> b) -> Keycode -> Keycode
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Keycode -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Keycode -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Keycode -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Keycode -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Keycode -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Keycode -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Keycode -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Keycode -> u
$cgmapM :: forall (m :: Type -> Type).
Monad m =>
(forall d. Data d => d -> m d) -> Keycode -> m Keycode
gmapM :: forall (m :: Type -> Type).
Monad m =>
(forall d. Data d => d -> m d) -> Keycode -> m Keycode
$cgmapMp :: forall (m :: Type -> Type).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Keycode -> m Keycode
gmapMp :: forall (m :: Type -> Type).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Keycode -> m Keycode
$cgmapMo :: forall (m :: Type -> Type).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Keycode -> m Keycode
gmapMo :: forall (m :: Type -> Type).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Keycode -> m Keycode
Data, Keycode -> Keycode -> Bool
(Keycode -> Keycode -> Bool)
-> (Keycode -> Keycode -> Bool) -> Eq Keycode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Keycode -> Keycode -> Bool
== :: Keycode -> Keycode -> Bool
$c/= :: Keycode -> Keycode -> Bool
/= :: Keycode -> Keycode -> Bool
Eq, Eq Keycode
Eq Keycode =>
(Keycode -> Keycode -> Ordering)
-> (Keycode -> Keycode -> Bool)
-> (Keycode -> Keycode -> Bool)
-> (Keycode -> Keycode -> Bool)
-> (Keycode -> Keycode -> Bool)
-> (Keycode -> Keycode -> Keycode)
-> (Keycode -> Keycode -> Keycode)
-> Ord Keycode
Keycode -> Keycode -> Bool
Keycode -> Keycode -> Ordering
Keycode -> Keycode -> Keycode
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Keycode -> Keycode -> Ordering
compare :: Keycode -> Keycode -> Ordering
$c< :: Keycode -> Keycode -> Bool
< :: Keycode -> Keycode -> Bool
$c<= :: Keycode -> Keycode -> Bool
<= :: Keycode -> Keycode -> Bool
$c> :: Keycode -> Keycode -> Bool
> :: Keycode -> Keycode -> Bool
$c>= :: Keycode -> Keycode -> Bool
>= :: Keycode -> Keycode -> Bool
$cmax :: Keycode -> Keycode -> Keycode
max :: Keycode -> Keycode -> Keycode
$cmin :: Keycode -> Keycode -> Keycode
min :: Keycode -> Keycode -> Keycode
Ord, ReadPrec [Keycode]
ReadPrec Keycode
Int -> ReadS Keycode
ReadS [Keycode]
(Int -> ReadS Keycode)
-> ReadS [Keycode]
-> ReadPrec Keycode
-> ReadPrec [Keycode]
-> Read Keycode
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Keycode
readsPrec :: Int -> ReadS Keycode
$creadList :: ReadS [Keycode]
readList :: ReadS [Keycode]
$creadPrec :: ReadPrec Keycode
readPrec :: ReadPrec Keycode
$creadListPrec :: ReadPrec [Keycode]
readListPrec :: ReadPrec [Keycode]
Read, (forall x. Keycode -> Rep Keycode x)
-> (forall x. Rep Keycode x -> Keycode) -> Generic Keycode
forall x. Rep Keycode x -> Keycode
forall x. Keycode -> Rep Keycode x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Keycode -> Rep Keycode x
from :: forall x. Keycode -> Rep Keycode x
$cto :: forall x. Rep Keycode x -> Keycode
to :: forall x. Rep Keycode x -> Keycode
Generic, Int -> Keycode -> ShowS
[Keycode] -> ShowS
Keycode -> String
(Int -> Keycode -> ShowS)
-> (Keycode -> String) -> ([Keycode] -> ShowS) -> Show Keycode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Keycode -> ShowS
showsPrec :: Int -> Keycode -> ShowS
$cshow :: Keycode -> String
show :: Keycode -> String
$cshowList :: [Keycode] -> ShowS
showList :: [Keycode] -> ShowS
Show, Typeable)

pattern $mKeycodeUnknown :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeUnknown :: Keycode
KeycodeUnknown = Keycode Raw.SDLK_UNKNOWN
pattern $mKeycodeReturn :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeReturn :: Keycode
KeycodeReturn = Keycode Raw.SDLK_RETURN
pattern $mKeycodeEscape :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeEscape :: Keycode
KeycodeEscape = Keycode Raw.SDLK_ESCAPE
pattern $mKeycodeBackspace :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeBackspace :: Keycode
KeycodeBackspace = Keycode Raw.SDLK_BACKSPACE
pattern $mKeycodeTab :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeTab :: Keycode
KeycodeTab = Keycode Raw.SDLK_TAB
pattern $mKeycodeSpace :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeSpace :: Keycode
KeycodeSpace = Keycode Raw.SDLK_SPACE
pattern $mKeycodeExclaim :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeExclaim :: Keycode
KeycodeExclaim = Keycode Raw.SDLK_EXCLAIM
pattern $mKeycodeQuoteDbl :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeQuoteDbl :: Keycode
KeycodeQuoteDbl = Keycode Raw.SDLK_QUOTEDBL
pattern $mKeycodeHash :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeHash :: Keycode
KeycodeHash = Keycode Raw.SDLK_HASH
pattern $mKeycodePercent :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodePercent :: Keycode
KeycodePercent = Keycode Raw.SDLK_PERCENT
pattern $mKeycodeDollar :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeDollar :: Keycode
KeycodeDollar = Keycode Raw.SDLK_DOLLAR
pattern $mKeycodeAmpersand :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeAmpersand :: Keycode
KeycodeAmpersand = Keycode Raw.SDLK_AMPERSAND
pattern $mKeycodeQuote :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeQuote :: Keycode
KeycodeQuote = Keycode Raw.SDLK_QUOTE
pattern $mKeycodeLeftParen :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeLeftParen :: Keycode
KeycodeLeftParen = Keycode Raw.SDLK_LEFTPAREN
pattern $mKeycodeRightParen :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeRightParen :: Keycode
KeycodeRightParen = Keycode Raw.SDLK_RIGHTPAREN
pattern $mKeycodeAsterisk :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeAsterisk :: Keycode
KeycodeAsterisk = Keycode Raw.SDLK_ASTERISK
pattern $mKeycodePlus :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodePlus :: Keycode
KeycodePlus = Keycode Raw.SDLK_PLUS
pattern $mKeycodeComma :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeComma :: Keycode
KeycodeComma = Keycode Raw.SDLK_COMMA
pattern $mKeycodeMinus :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeMinus :: Keycode
KeycodeMinus = Keycode Raw.SDLK_MINUS
pattern $mKeycodePeriod :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodePeriod :: Keycode
KeycodePeriod = Keycode Raw.SDLK_PERIOD
pattern $mKeycodeSlash :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeSlash :: Keycode
KeycodeSlash = Keycode Raw.SDLK_SLASH
pattern $mKeycode0 :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycode0 :: Keycode
Keycode0 = Keycode Raw.SDLK_0
pattern $mKeycode1 :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycode1 :: Keycode
Keycode1 = Keycode Raw.SDLK_1
pattern $mKeycode2 :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycode2 :: Keycode
Keycode2 = Keycode Raw.SDLK_2
pattern $mKeycode3 :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycode3 :: Keycode
Keycode3 = Keycode Raw.SDLK_3
pattern $mKeycode4 :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycode4 :: Keycode
Keycode4 = Keycode Raw.SDLK_4
pattern $mKeycode5 :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycode5 :: Keycode
Keycode5 = Keycode Raw.SDLK_5
pattern $mKeycode6 :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycode6 :: Keycode
Keycode6 = Keycode Raw.SDLK_6
pattern $mKeycode7 :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycode7 :: Keycode
Keycode7 = Keycode Raw.SDLK_7
pattern $mKeycode8 :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycode8 :: Keycode
Keycode8 = Keycode Raw.SDLK_8
pattern $mKeycode9 :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycode9 :: Keycode
Keycode9 = Keycode Raw.SDLK_9
pattern $mKeycodeColon :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeColon :: Keycode
KeycodeColon = Keycode Raw.SDLK_COLON
pattern $mKeycodeSemicolon :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeSemicolon :: Keycode
KeycodeSemicolon = Keycode Raw.SDLK_SEMICOLON
pattern $mKeycodeLess :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeLess :: Keycode
KeycodeLess = Keycode Raw.SDLK_LESS
pattern $mKeycodeEquals :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeEquals :: Keycode
KeycodeEquals = Keycode Raw.SDLK_EQUALS
pattern $mKeycodeGreater :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeGreater :: Keycode
KeycodeGreater = Keycode Raw.SDLK_GREATER
pattern $mKeycodeQuestion :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeQuestion :: Keycode
KeycodeQuestion = Keycode Raw.SDLK_QUESTION
pattern $mKeycodeAt :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeAt :: Keycode
KeycodeAt = Keycode Raw.SDLK_AT
pattern $mKeycodeLeftBracket :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeLeftBracket :: Keycode
KeycodeLeftBracket = Keycode Raw.SDLK_LEFTBRACKET
pattern $mKeycodeBackslash :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeBackslash :: Keycode
KeycodeBackslash = Keycode Raw.SDLK_BACKSLASH
pattern $mKeycodeRightBracket :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeRightBracket :: Keycode
KeycodeRightBracket = Keycode Raw.SDLK_RIGHTBRACKET
pattern $mKeycodeCaret :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeCaret :: Keycode
KeycodeCaret = Keycode Raw.SDLK_CARET
pattern $mKeycodeUnderscore :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeUnderscore :: Keycode
KeycodeUnderscore = Keycode Raw.SDLK_UNDERSCORE
pattern $mKeycodeBackquote :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeBackquote :: Keycode
KeycodeBackquote = Keycode Raw.SDLK_BACKQUOTE
pattern $mKeycodeA :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeA :: Keycode
KeycodeA = Keycode Raw.SDLK_a
pattern $mKeycodeB :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeB :: Keycode
KeycodeB = Keycode Raw.SDLK_b
pattern $mKeycodeC :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeC :: Keycode
KeycodeC = Keycode Raw.SDLK_c
pattern $mKeycodeD :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeD :: Keycode
KeycodeD = Keycode Raw.SDLK_d
pattern $mKeycodeE :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeE :: Keycode
KeycodeE = Keycode Raw.SDLK_e
pattern $mKeycodeF :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeF :: Keycode
KeycodeF = Keycode Raw.SDLK_f
pattern $mKeycodeG :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeG :: Keycode
KeycodeG = Keycode Raw.SDLK_g
pattern $mKeycodeH :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeH :: Keycode
KeycodeH = Keycode Raw.SDLK_h
pattern $mKeycodeI :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeI :: Keycode
KeycodeI = Keycode Raw.SDLK_i
pattern $mKeycodeJ :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeJ :: Keycode
KeycodeJ = Keycode Raw.SDLK_j
pattern $mKeycodeK :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeK :: Keycode
KeycodeK = Keycode Raw.SDLK_k
pattern $mKeycodeL :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeL :: Keycode
KeycodeL = Keycode Raw.SDLK_l
pattern $mKeycodeM :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeM :: Keycode
KeycodeM = Keycode Raw.SDLK_m
pattern $mKeycodeN :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeN :: Keycode
KeycodeN = Keycode Raw.SDLK_n
pattern $mKeycodeO :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeO :: Keycode
KeycodeO = Keycode Raw.SDLK_o
pattern $mKeycodeP :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeP :: Keycode
KeycodeP = Keycode Raw.SDLK_p
pattern $mKeycodeQ :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeQ :: Keycode
KeycodeQ = Keycode Raw.SDLK_q
pattern $mKeycodeR :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeR :: Keycode
KeycodeR = Keycode Raw.SDLK_r
pattern $mKeycodeS :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeS :: Keycode
KeycodeS = Keycode Raw.SDLK_s
pattern $mKeycodeT :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeT :: Keycode
KeycodeT = Keycode Raw.SDLK_t
pattern $mKeycodeU :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeU :: Keycode
KeycodeU = Keycode Raw.SDLK_u
pattern $mKeycodeV :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeV :: Keycode
KeycodeV = Keycode Raw.SDLK_v
pattern $mKeycodeW :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeW :: Keycode
KeycodeW = Keycode Raw.SDLK_w
pattern $mKeycodeX :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeX :: Keycode
KeycodeX = Keycode Raw.SDLK_x
pattern $mKeycodeY :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeY :: Keycode
KeycodeY = Keycode Raw.SDLK_y
pattern $mKeycodeZ :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeZ :: Keycode
KeycodeZ = Keycode Raw.SDLK_z
pattern $mKeycodeCapsLock :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeCapsLock :: Keycode
KeycodeCapsLock = Keycode Raw.SDLK_CAPSLOCK
pattern $mKeycodeF1 :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeF1 :: Keycode
KeycodeF1 = Keycode Raw.SDLK_F1
pattern $mKeycodeF2 :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeF2 :: Keycode
KeycodeF2 = Keycode Raw.SDLK_F2
pattern $mKeycodeF3 :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeF3 :: Keycode
KeycodeF3 = Keycode Raw.SDLK_F3
pattern $mKeycodeF4 :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeF4 :: Keycode
KeycodeF4 = Keycode Raw.SDLK_F4
pattern $mKeycodeF5 :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeF5 :: Keycode
KeycodeF5 = Keycode Raw.SDLK_F5
pattern $mKeycodeF6 :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeF6 :: Keycode
KeycodeF6 = Keycode Raw.SDLK_F6
pattern $mKeycodeF7 :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeF7 :: Keycode
KeycodeF7 = Keycode Raw.SDLK_F7
pattern $mKeycodeF8 :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeF8 :: Keycode
KeycodeF8 = Keycode Raw.SDLK_F8
pattern $mKeycodeF9 :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeF9 :: Keycode
KeycodeF9 = Keycode Raw.SDLK_F9
pattern $mKeycodeF10 :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeF10 :: Keycode
KeycodeF10 = Keycode Raw.SDLK_F10
pattern $mKeycodeF11 :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeF11 :: Keycode
KeycodeF11 = Keycode Raw.SDLK_F11
pattern $mKeycodeF12 :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeF12 :: Keycode
KeycodeF12 = Keycode Raw.SDLK_F12
pattern $mKeycodePrintScreen :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodePrintScreen :: Keycode
KeycodePrintScreen = Keycode Raw.SDLK_PRINTSCREEN
pattern $mKeycodeScrollLock :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeScrollLock :: Keycode
KeycodeScrollLock = Keycode Raw.SDLK_SCROLLLOCK
pattern $mKeycodePause :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodePause :: Keycode
KeycodePause = Keycode Raw.SDLK_PAUSE
pattern $mKeycodeInsert :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeInsert :: Keycode
KeycodeInsert = Keycode Raw.SDLK_INSERT
pattern $mKeycodeHome :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeHome :: Keycode
KeycodeHome = Keycode Raw.SDLK_HOME
pattern $mKeycodePageUp :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodePageUp :: Keycode
KeycodePageUp = Keycode Raw.SDLK_PAGEUP
pattern $mKeycodeDelete :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeDelete :: Keycode
KeycodeDelete = Keycode Raw.SDLK_DELETE
pattern $mKeycodeEnd :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeEnd :: Keycode
KeycodeEnd = Keycode Raw.SDLK_END
pattern $mKeycodePageDown :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodePageDown :: Keycode
KeycodePageDown = Keycode Raw.SDLK_PAGEDOWN
pattern $mKeycodeRight :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeRight :: Keycode
KeycodeRight = Keycode Raw.SDLK_RIGHT
pattern $mKeycodeLeft :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeLeft :: Keycode
KeycodeLeft = Keycode Raw.SDLK_LEFT
pattern $mKeycodeDown :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeDown :: Keycode
KeycodeDown = Keycode Raw.SDLK_DOWN
pattern $mKeycodeUp :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeUp :: Keycode
KeycodeUp = Keycode Raw.SDLK_UP
pattern $mKeycodeNumLockClear :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeNumLockClear :: Keycode
KeycodeNumLockClear = Keycode Raw.SDLK_NUMLOCKCLEAR
pattern $mKeycodeKPDivide :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKPDivide :: Keycode
KeycodeKPDivide = Keycode Raw.SDLK_KP_DIVIDE
pattern $mKeycodeKPMultiply :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKPMultiply :: Keycode
KeycodeKPMultiply = Keycode Raw.SDLK_KP_MULTIPLY
pattern $mKeycodeKPMinus :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKPMinus :: Keycode
KeycodeKPMinus = Keycode Raw.SDLK_KP_MINUS
pattern $mKeycodeKPPlus :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKPPlus :: Keycode
KeycodeKPPlus = Keycode Raw.SDLK_KP_PLUS
pattern $mKeycodeKPEnter :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKPEnter :: Keycode
KeycodeKPEnter = Keycode Raw.SDLK_KP_ENTER
pattern $mKeycodeKP1 :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKP1 :: Keycode
KeycodeKP1 = Keycode Raw.SDLK_KP_1
pattern $mKeycodeKP2 :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKP2 :: Keycode
KeycodeKP2 = Keycode Raw.SDLK_KP_2
pattern $mKeycodeKP3 :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKP3 :: Keycode
KeycodeKP3 = Keycode Raw.SDLK_KP_3
pattern $mKeycodeKP4 :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKP4 :: Keycode
KeycodeKP4 = Keycode Raw.SDLK_KP_4
pattern $mKeycodeKP5 :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKP5 :: Keycode
KeycodeKP5 = Keycode Raw.SDLK_KP_5
pattern $mKeycodeKP6 :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKP6 :: Keycode
KeycodeKP6 = Keycode Raw.SDLK_KP_6
pattern $mKeycodeKP7 :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKP7 :: Keycode
KeycodeKP7 = Keycode Raw.SDLK_KP_7
pattern $mKeycodeKP8 :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKP8 :: Keycode
KeycodeKP8 = Keycode Raw.SDLK_KP_8
pattern $mKeycodeKP9 :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKP9 :: Keycode
KeycodeKP9 = Keycode Raw.SDLK_KP_9
pattern $mKeycodeKP0 :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKP0 :: Keycode
KeycodeKP0 = Keycode Raw.SDLK_KP_0
pattern $mKeycodeKPPeriod :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKPPeriod :: Keycode
KeycodeKPPeriod = Keycode Raw.SDLK_KP_PERIOD
pattern $mKeycodeApplication :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeApplication :: Keycode
KeycodeApplication = Keycode Raw.SDLK_APPLICATION
pattern $mKeycodePower :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodePower :: Keycode
KeycodePower = Keycode Raw.SDLK_POWER
pattern $mKeycodeKPEquals :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKPEquals :: Keycode
KeycodeKPEquals = Keycode Raw.SDLK_KP_EQUALS
pattern $mKeycodeF13 :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeF13 :: Keycode
KeycodeF13 = Keycode Raw.SDLK_F13
pattern $mKeycodeF14 :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeF14 :: Keycode
KeycodeF14 = Keycode Raw.SDLK_F14
pattern $mKeycodeF15 :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeF15 :: Keycode
KeycodeF15 = Keycode Raw.SDLK_F15
pattern $mKeycodeF16 :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeF16 :: Keycode
KeycodeF16 = Keycode Raw.SDLK_F16
pattern $mKeycodeF17 :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeF17 :: Keycode
KeycodeF17 = Keycode Raw.SDLK_F17
pattern $mKeycodeF18 :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeF18 :: Keycode
KeycodeF18 = Keycode Raw.SDLK_F18
pattern $mKeycodeF19 :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeF19 :: Keycode
KeycodeF19 = Keycode Raw.SDLK_F19
pattern $mKeycodeF20 :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeF20 :: Keycode
KeycodeF20 = Keycode Raw.SDLK_F20
pattern $mKeycodeF21 :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeF21 :: Keycode
KeycodeF21 = Keycode Raw.SDLK_F21
pattern $mKeycodeF22 :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeF22 :: Keycode
KeycodeF22 = Keycode Raw.SDLK_F22
pattern $mKeycodeF23 :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeF23 :: Keycode
KeycodeF23 = Keycode Raw.SDLK_F23
pattern $mKeycodeF24 :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeF24 :: Keycode
KeycodeF24 = Keycode Raw.SDLK_F24
pattern $mKeycodeExecute :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeExecute :: Keycode
KeycodeExecute = Keycode Raw.SDLK_EXECUTE
pattern $mKeycodeHelp :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeHelp :: Keycode
KeycodeHelp = Keycode Raw.SDLK_HELP
pattern $mKeycodeMenu :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeMenu :: Keycode
KeycodeMenu = Keycode Raw.SDLK_MENU
pattern $mKeycodeSelect :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeSelect :: Keycode
KeycodeSelect = Keycode Raw.SDLK_SELECT
pattern $mKeycodeStop :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeStop :: Keycode
KeycodeStop = Keycode Raw.SDLK_STOP
pattern $mKeycodeAgain :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeAgain :: Keycode
KeycodeAgain = Keycode Raw.SDLK_AGAIN
pattern $mKeycodeUndo :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeUndo :: Keycode
KeycodeUndo = Keycode Raw.SDLK_UNDO
pattern $mKeycodeCut :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeCut :: Keycode
KeycodeCut = Keycode Raw.SDLK_CUT
pattern $mKeycodeCopy :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeCopy :: Keycode
KeycodeCopy = Keycode Raw.SDLK_COPY
pattern $mKeycodePaste :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodePaste :: Keycode
KeycodePaste = Keycode Raw.SDLK_PASTE
pattern $mKeycodeFind :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeFind :: Keycode
KeycodeFind = Keycode Raw.SDLK_FIND
pattern $mKeycodeMute :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeMute :: Keycode
KeycodeMute = Keycode Raw.SDLK_MUTE
pattern $mKeycodeVolumeUp :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeVolumeUp :: Keycode
KeycodeVolumeUp = Keycode Raw.SDLK_VOLUMEUP
pattern $mKeycodeVolumeDown :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeVolumeDown :: Keycode
KeycodeVolumeDown = Keycode Raw.SDLK_VOLUMEDOWN
pattern $mKeycodeKPComma :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKPComma :: Keycode
KeycodeKPComma = Keycode Raw.SDLK_KP_COMMA
pattern $mKeycodeKPEqualsAS400 :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKPEqualsAS400 :: Keycode
KeycodeKPEqualsAS400 = Keycode Raw.SDLK_KP_EQUALSAS400
pattern $mKeycodeAltErase :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeAltErase :: Keycode
KeycodeAltErase = Keycode Raw.SDLK_ALTERASE
pattern $mKeycodeSysReq :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeSysReq :: Keycode
KeycodeSysReq = Keycode Raw.SDLK_SYSREQ
pattern $mKeycodeCancel :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeCancel :: Keycode
KeycodeCancel = Keycode Raw.SDLK_CANCEL
pattern $mKeycodeClear :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeClear :: Keycode
KeycodeClear = Keycode Raw.SDLK_CLEAR
pattern $mKeycodePrior :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodePrior :: Keycode
KeycodePrior = Keycode Raw.SDLK_PRIOR
pattern $mKeycodeReturn2 :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeReturn2 :: Keycode
KeycodeReturn2 = Keycode Raw.SDLK_RETURN2
pattern $mKeycodeSeparator :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeSeparator :: Keycode
KeycodeSeparator = Keycode Raw.SDLK_SEPARATOR
pattern $mKeycodeOut :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeOut :: Keycode
KeycodeOut = Keycode Raw.SDLK_OUT
pattern $mKeycodeOper :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeOper :: Keycode
KeycodeOper = Keycode Raw.SDLK_OPER
pattern $mKeycodeClearAgain :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeClearAgain :: Keycode
KeycodeClearAgain = Keycode Raw.SDLK_CLEARAGAIN
pattern $mKeycodeCrSel :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeCrSel :: Keycode
KeycodeCrSel = Keycode Raw.SDLK_CRSEL
pattern $mKeycodeExSel :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeExSel :: Keycode
KeycodeExSel = Keycode Raw.SDLK_EXSEL
pattern $mKeycodeKP00 :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKP00 :: Keycode
KeycodeKP00 = Keycode Raw.SDLK_KP_00
pattern $mKeycodeKP000 :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKP000 :: Keycode
KeycodeKP000 = Keycode Raw.SDLK_KP_000
pattern $mKeycodeThousandsSeparator :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeThousandsSeparator :: Keycode
KeycodeThousandsSeparator = Keycode Raw.SDLK_THOUSANDSSEPARATOR
pattern $mKeycodeDecimalSeparator :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeDecimalSeparator :: Keycode
KeycodeDecimalSeparator = Keycode Raw.SDLK_DECIMALSEPARATOR
pattern $mKeycodeCurrencyUnit :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeCurrencyUnit :: Keycode
KeycodeCurrencyUnit = Keycode Raw.SDLK_CURRENCYUNIT
pattern $mKeycodeCurrencySubunit :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeCurrencySubunit :: Keycode
KeycodeCurrencySubunit = Keycode Raw.SDLK_CURRENCYSUBUNIT
pattern $mKeycodeKPLeftParen :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKPLeftParen :: Keycode
KeycodeKPLeftParen = Keycode Raw.SDLK_KP_LEFTPAREN
pattern $mKeycodeKPRightParen :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKPRightParen :: Keycode
KeycodeKPRightParen = Keycode Raw.SDLK_KP_RIGHTPAREN
pattern $mKeycodeKPLeftBrace :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKPLeftBrace :: Keycode
KeycodeKPLeftBrace = Keycode Raw.SDLK_KP_LEFTBRACE
pattern $mKeycodeKPRightBrace :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKPRightBrace :: Keycode
KeycodeKPRightBrace = Keycode Raw.SDLK_KP_RIGHTBRACE
pattern $mKeycodeKPTab :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKPTab :: Keycode
KeycodeKPTab = Keycode Raw.SDLK_KP_TAB
pattern $mKeycodeKPBackspace :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKPBackspace :: Keycode
KeycodeKPBackspace = Keycode Raw.SDLK_KP_BACKSPACE
pattern $mKeycodeKPA :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKPA :: Keycode
KeycodeKPA = Keycode Raw.SDLK_KP_A
pattern $mKeycodeKPB :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKPB :: Keycode
KeycodeKPB = Keycode Raw.SDLK_KP_B
pattern $mKeycodeKPC :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKPC :: Keycode
KeycodeKPC = Keycode Raw.SDLK_KP_C
pattern $mKeycodeKPD :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKPD :: Keycode
KeycodeKPD = Keycode Raw.SDLK_KP_D
pattern $mKeycodeKPE :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKPE :: Keycode
KeycodeKPE = Keycode Raw.SDLK_KP_E
pattern $mKeycodeKPF :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKPF :: Keycode
KeycodeKPF = Keycode Raw.SDLK_KP_F
pattern $mKeycodeKPXor :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKPXor :: Keycode
KeycodeKPXor = Keycode Raw.SDLK_KP_XOR
pattern $mKeycodeKPPower :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKPPower :: Keycode
KeycodeKPPower = Keycode Raw.SDLK_KP_POWER
pattern $mKeycodeKPPercent :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKPPercent :: Keycode
KeycodeKPPercent = Keycode Raw.SDLK_KP_PERCENT
pattern $mKeycodeKPLess :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKPLess :: Keycode
KeycodeKPLess = Keycode Raw.SDLK_KP_LESS
pattern $mKeycodeKPGreater :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKPGreater :: Keycode
KeycodeKPGreater = Keycode Raw.SDLK_KP_GREATER
pattern $mKeycodeKPAmpersand :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKPAmpersand :: Keycode
KeycodeKPAmpersand = Keycode Raw.SDLK_KP_AMPERSAND
pattern $mKeycodeKPDblAmpersand :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKPDblAmpersand :: Keycode
KeycodeKPDblAmpersand = Keycode Raw.SDLK_KP_DBLAMPERSAND
pattern $mKeycodeKPVerticalBar :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKPVerticalBar :: Keycode
KeycodeKPVerticalBar = Keycode Raw.SDLK_KP_VERTICALBAR
pattern $mKeycodeKPDblVerticalBar :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKPDblVerticalBar :: Keycode
KeycodeKPDblVerticalBar = Keycode Raw.SDLK_KP_DBLVERTICALBAR
pattern $mKeycodeKPColon :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKPColon :: Keycode
KeycodeKPColon = Keycode Raw.SDLK_KP_COLON
pattern $mKeycodeKPHash :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKPHash :: Keycode
KeycodeKPHash = Keycode Raw.SDLK_KP_HASH
pattern $mKeycodeKPSpace :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKPSpace :: Keycode
KeycodeKPSpace = Keycode Raw.SDLK_KP_SPACE
pattern $mKeycodeKPAt :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKPAt :: Keycode
KeycodeKPAt = Keycode Raw.SDLK_KP_AT
pattern $mKeycodeKPExclam :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKPExclam :: Keycode
KeycodeKPExclam = Keycode Raw.SDLK_KP_EXCLAM
pattern $mKeycodeKPMemStore :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKPMemStore :: Keycode
KeycodeKPMemStore = Keycode Raw.SDLK_KP_MEMSTORE
pattern $mKeycodeKPMemRecall :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKPMemRecall :: Keycode
KeycodeKPMemRecall = Keycode Raw.SDLK_KP_MEMRECALL
pattern $mKeycodeKPMemClear :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKPMemClear :: Keycode
KeycodeKPMemClear = Keycode Raw.SDLK_KP_MEMCLEAR
pattern $mKeycodeKPMemAdd :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKPMemAdd :: Keycode
KeycodeKPMemAdd = Keycode Raw.SDLK_KP_MEMADD
pattern $mKeycodeKPMemSubtract :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKPMemSubtract :: Keycode
KeycodeKPMemSubtract = Keycode Raw.SDLK_KP_MEMSUBTRACT
pattern $mKeycodeKPMemMultiply :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKPMemMultiply :: Keycode
KeycodeKPMemMultiply = Keycode Raw.SDLK_KP_MEMMULTIPLY
pattern $mKeycodeKPMemDivide :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKPMemDivide :: Keycode
KeycodeKPMemDivide = Keycode Raw.SDLK_KP_MEMDIVIDE
pattern $mKeycodeKPPlusMinus :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKPPlusMinus :: Keycode
KeycodeKPPlusMinus = Keycode Raw.SDLK_KP_PLUSMINUS
pattern $mKeycodeKPClear :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKPClear :: Keycode
KeycodeKPClear = Keycode Raw.SDLK_KP_CLEAR
pattern $mKeycodeKPClearEntry :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKPClearEntry :: Keycode
KeycodeKPClearEntry = Keycode Raw.SDLK_KP_CLEARENTRY
pattern $mKeycodeKPBinary :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKPBinary :: Keycode
KeycodeKPBinary = Keycode Raw.SDLK_KP_BINARY
pattern $mKeycodeKPOctal :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKPOctal :: Keycode
KeycodeKPOctal = Keycode Raw.SDLK_KP_OCTAL
pattern $mKeycodeKPDecimal :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKPDecimal :: Keycode
KeycodeKPDecimal = Keycode Raw.SDLK_KP_DECIMAL
pattern $mKeycodeKPHexadecimal :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKPHexadecimal :: Keycode
KeycodeKPHexadecimal = Keycode Raw.SDLK_KP_HEXADECIMAL
pattern $mKeycodeLCtrl :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeLCtrl :: Keycode
KeycodeLCtrl = Keycode Raw.SDLK_LCTRL
pattern $mKeycodeLShift :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeLShift :: Keycode
KeycodeLShift = Keycode Raw.SDLK_LSHIFT
pattern $mKeycodeLAlt :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeLAlt :: Keycode
KeycodeLAlt = Keycode Raw.SDLK_LALT
pattern $mKeycodeLGUI :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeLGUI :: Keycode
KeycodeLGUI = Keycode Raw.SDLK_LGUI
pattern $mKeycodeRCtrl :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeRCtrl :: Keycode
KeycodeRCtrl = Keycode Raw.SDLK_RCTRL
pattern $mKeycodeRShift :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeRShift :: Keycode
KeycodeRShift = Keycode Raw.SDLK_RSHIFT
pattern $mKeycodeRAlt :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeRAlt :: Keycode
KeycodeRAlt = Keycode Raw.SDLK_RALT
pattern $mKeycodeRGUI :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeRGUI :: Keycode
KeycodeRGUI = Keycode Raw.SDLK_RGUI
pattern $mKeycodeMode :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeMode :: Keycode
KeycodeMode = Keycode Raw.SDLK_MODE
pattern $mKeycodeAudioNext :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeAudioNext :: Keycode
KeycodeAudioNext = Keycode Raw.SDLK_AUDIONEXT
pattern $mKeycodeAudioPrev :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeAudioPrev :: Keycode
KeycodeAudioPrev = Keycode Raw.SDLK_AUDIOPREV
pattern $mKeycodeAudioStop :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeAudioStop :: Keycode
KeycodeAudioStop = Keycode Raw.SDLK_AUDIOSTOP
pattern $mKeycodeAudioPlay :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeAudioPlay :: Keycode
KeycodeAudioPlay = Keycode Raw.SDLK_AUDIOPLAY
pattern $mKeycodeAudioMute :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeAudioMute :: Keycode
KeycodeAudioMute = Keycode Raw.SDLK_AUDIOMUTE
pattern $mKeycodeMediaSelect :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeMediaSelect :: Keycode
KeycodeMediaSelect = Keycode Raw.SDLK_MEDIASELECT
pattern $mKeycodeWWW :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeWWW :: Keycode
KeycodeWWW = Keycode Raw.SDLK_WWW
pattern $mKeycodeMail :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeMail :: Keycode
KeycodeMail = Keycode Raw.SDLK_MAIL
pattern $mKeycodeCalculator :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeCalculator :: Keycode
KeycodeCalculator = Keycode Raw.SDLK_CALCULATOR
pattern $mKeycodeComputer :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeComputer :: Keycode
KeycodeComputer = Keycode Raw.SDLK_COMPUTER
pattern $mKeycodeACSearch :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeACSearch :: Keycode
KeycodeACSearch = Keycode Raw.SDLK_AC_SEARCH
pattern $mKeycodeACHome :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeACHome :: Keycode
KeycodeACHome = Keycode Raw.SDLK_AC_HOME
pattern $mKeycodeACBack :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeACBack :: Keycode
KeycodeACBack = Keycode Raw.SDLK_AC_BACK
pattern $mKeycodeACForward :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeACForward :: Keycode
KeycodeACForward = Keycode Raw.SDLK_AC_FORWARD
pattern $mKeycodeACStop :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeACStop :: Keycode
KeycodeACStop = Keycode Raw.SDLK_AC_STOP
pattern $mKeycodeACRefresh :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeACRefresh :: Keycode
KeycodeACRefresh = Keycode Raw.SDLK_AC_REFRESH
pattern $mKeycodeACBookmarks :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeACBookmarks :: Keycode
KeycodeACBookmarks = Keycode Raw.SDLK_AC_BOOKMARKS
pattern $mKeycodeBrightnessDown :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeBrightnessDown :: Keycode
KeycodeBrightnessDown = Keycode Raw.SDLK_BRIGHTNESSDOWN
pattern $mKeycodeBrightnessUp :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeBrightnessUp :: Keycode
KeycodeBrightnessUp = Keycode Raw.SDLK_BRIGHTNESSUP
pattern $mKeycodeDisplaySwitch :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeDisplaySwitch :: Keycode
KeycodeDisplaySwitch = Keycode Raw.SDLK_DISPLAYSWITCH
pattern $mKeycodeKbdIllumToggle :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKbdIllumToggle :: Keycode
KeycodeKbdIllumToggle = Keycode Raw.SDLK_KBDILLUMTOGGLE
pattern $mKeycodeKbdIllumDown :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKbdIllumDown :: Keycode
KeycodeKbdIllumDown = Keycode Raw.SDLK_KBDILLUMDOWN
pattern $mKeycodeKbdIllumUp :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeKbdIllumUp :: Keycode
KeycodeKbdIllumUp = Keycode Raw.SDLK_KBDILLUMUP
pattern $mKeycodeEject :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeEject :: Keycode
KeycodeEject = Keycode Raw.SDLK_EJECT
pattern $mKeycodeSleep :: forall {r}. Keycode -> ((# #) -> r) -> ((# #) -> r) -> r
$bKeycodeSleep :: Keycode
KeycodeSleep = Keycode Raw.SDLK_SLEEP

instance FromNumber Keycode Int32 where
  fromNumber :: Int32 -> Keycode
fromNumber = Int32 -> Keycode
Keycode

instance ToNumber Keycode Int32 where
  toNumber :: Keycode -> Int32
toNumber = Keycode -> Int32
unwrapKeycode