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

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

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