Beispiel #1
0
        static void HandleKeyEvent(SDL.SDL_Keycode keyCode, Chip8 core, bool pressed)
        {
            switch (keyCode)
            {
            case SDL.SDL_Keycode.SDLK_1:
                core.SetKey(1, pressed);
                break;

            case SDL.SDL_Keycode.SDLK_2:
                core.SetKey(2, pressed);
                break;

            case SDL.SDL_Keycode.SDLK_3:
                core.SetKey(3, pressed);
                break;

            case SDL.SDL_Keycode.SDLK_4:
                core.SetKey(12, pressed);
                break;

            case SDL.SDL_Keycode.SDLK_a:
                core.SetKey(4, pressed);
                break;

            case SDL.SDL_Keycode.SDLK_z:
                core.SetKey(5, pressed);
                break;

            case SDL.SDL_Keycode.SDLK_e:
                core.SetKey(6, pressed);
                break;

            case SDL.SDL_Keycode.SDLK_r:
                core.SetKey(13, pressed);
                break;

            case SDL.SDL_Keycode.SDLK_q:
                core.SetKey(7, pressed);
                break;

            case SDL.SDL_Keycode.SDLK_s:
                core.SetKey(8, pressed);
                break;

            case SDL.SDL_Keycode.SDLK_d:
                core.SetKey(9, pressed);
                break;

            case SDL.SDL_Keycode.SDLK_f:
                core.SetKey(14, pressed);
                break;

            case SDL.SDL_Keycode.SDLK_w:
                core.SetKey(10, pressed);
                break;

            case SDL.SDL_Keycode.SDLK_x:
                core.SetKey(0, pressed);
                break;

            case SDL.SDL_Keycode.SDLK_c:
                core.SetKey(11, pressed);
                break;

            case SDL.SDL_Keycode.SDLK_v:
                core.SetKey(15, pressed);
                break;
            }
        }
        private static string getConfigValue(Input input)
        {
            if (input.Type == "button")
            {
                return(input.Id.ToString());
            }

            if (input.Type == "axis")
            {
                if (input.Value < 0)
                {
                    return("-" + input.Id.ToString());
                }
                else
                {
                    return("+" + input.Id.ToString());
                }
            }

            if (_inputDriver == "sdl2")
            {            // sdl2
                if (input.Type == "hat")
                {
                    if (input.Value == 2) // SDL_HAT_RIGHT
                    {
                        return("14");
                    }
                    else if (input.Value == 4) // SDL_HAT_DOWN
                    {
                        return("12");
                    }
                    else if (input.Value == 8) // SDL_HAT_LEFT
                    {
                        return("13");
                    }

                    return("11"); // UP
                }
            }
            else
            {
                // xinput / directInput
                if (input.Type == "hat")
                {
                    if (input.Value == 2) // SDL_HAT_RIGHT
                    {
                        return("h" + input.Id + "right");
                    }
                    else if (input.Value == 4) // SDL_HAT_DOWN
                    {
                        return("h" + input.Id + "down");
                    }
                    else if (input.Value == 8) // SDL_HAT_LEFT
                    {
                        return("h" + input.Id + "left");
                    }

                    return("h" + input.Id + "up"); // UP
                }
            }

            if (input.Type == "key")
            {
                int        id            = (int)input.Id;
                List <int> azertyLayouts = new List <int>()
                {
                    1036, 2060, 3084, 5132, 4108
                };
                if (azertyLayouts.Contains(CultureInfo.CurrentCulture.KeyboardLayoutId))
                {
                    if (id == 'a')
                    {
                        id = 'q';
                    }
                    else if (id == 'q')
                    {
                        id = 'a';
                    }
                    else if (id == 'w')
                    {
                        id = 'z';
                    }
                    else if (id == 'z')
                    {
                        id = 'w';
                    }
                }

                SDL.SDL_Keycode code = (SDL.SDL_Keycode)id;

                if (input_config_key_map.ContainsKey(code))
                {
                    var rk   = input_config_key_map[code];
                    var test = input_config_names.Where(i => i.Value == rk).Select(i => i.Key).FirstOrDefault();
                    if (test != null)
                    {
                        return(test);
                    }
                }

                return(((char)id).ToString());
            }

            return(input.Id.ToString());
        }
Beispiel #3
0
        public static Keys MapSdlKey(SDL.SDL_Keycode keyCode)
        {
            switch (keyCode)
            {
            case SDL.SDL_Keycode.SDLK_UNKNOWN:
                return(Keys.Unknown);

            case SDL.SDL_Keycode.SDLK_RETURN:
                return(Keys.Return);

            case SDL.SDL_Keycode.SDLK_ESCAPE:
                return(Keys.Escape);

            case SDL.SDL_Keycode.SDLK_BACKSPACE:
                return(Keys.Backspace);

            case SDL.SDL_Keycode.SDLK_TAB:
                return(Keys.Tab);

            case SDL.SDL_Keycode.SDLK_SPACE:
                return(Keys.Space);

            case SDL.SDL_Keycode.SDLK_EXCLAIM:
                return(Keys.Exclaim);

            case SDL.SDL_Keycode.SDLK_QUOTEDBL:
                return(Keys.QuoteDouble);

            case SDL.SDL_Keycode.SDLK_HASH:
                return(Keys.Hash);

            case SDL.SDL_Keycode.SDLK_PERCENT:
                return(Keys.Percent);

            case SDL.SDL_Keycode.SDLK_DOLLAR:
                return(Keys.Dollar);

            case SDL.SDL_Keycode.SDLK_AMPERSAND:
                return(Keys.Ampersand);

            case SDL.SDL_Keycode.SDLK_QUOTE:
                return(Keys.Quote);

            case SDL.SDL_Keycode.SDLK_LEFTPAREN:
                return(Keys.LeftParenthesis);

            case SDL.SDL_Keycode.SDLK_RIGHTPAREN:
                return(Keys.RightParenthesis);

            case SDL.SDL_Keycode.SDLK_ASTERISK:
                return(Keys.Asterisk);

            case SDL.SDL_Keycode.SDLK_PLUS:
                return(Keys.Plus);

            case SDL.SDL_Keycode.SDLK_COMMA:
                return(Keys.Comma);

            case SDL.SDL_Keycode.SDLK_MINUS:
                return(Keys.Minus);

            case SDL.SDL_Keycode.SDLK_PERIOD:
                return(Keys.Period);

            case SDL.SDL_Keycode.SDLK_SLASH:
                return(Keys.Slash);

            case SDL.SDL_Keycode.SDLK_0:
                return(Keys.Key0);

            case SDL.SDL_Keycode.SDLK_1:
                return(Keys.Key1);

            case SDL.SDL_Keycode.SDLK_2:
                return(Keys.Key2);

            case SDL.SDL_Keycode.SDLK_3:
                return(Keys.Key3);

            case SDL.SDL_Keycode.SDLK_4:
                return(Keys.Key4);

            case SDL.SDL_Keycode.SDLK_5:
                return(Keys.Key5);

            case SDL.SDL_Keycode.SDLK_6:
                return(Keys.Key6);

            case SDL.SDL_Keycode.SDLK_7:
                return(Keys.Key7);

            case SDL.SDL_Keycode.SDLK_8:
                return(Keys.Key8);

            case SDL.SDL_Keycode.SDLK_9:
                return(Keys.Key9);

            case SDL.SDL_Keycode.SDLK_COLON:
                return(Keys.Colon);

            case SDL.SDL_Keycode.SDLK_SEMICOLON:
                return(Keys.Semicolon);

            case SDL.SDL_Keycode.SDLK_LESS:
                return(Keys.Less);

            case SDL.SDL_Keycode.SDLK_EQUALS:
                return(Keys.Equals);

            case SDL.SDL_Keycode.SDLK_GREATER:
                return(Keys.Greater);

            case SDL.SDL_Keycode.SDLK_QUESTION:
                return(Keys.Question);

            case SDL.SDL_Keycode.SDLK_AT:
                return(Keys.At);

            case SDL.SDL_Keycode.SDLK_LEFTBRACKET:
                return(Keys.LeftBracket);

            case SDL.SDL_Keycode.SDLK_BACKSLASH:
                return(Keys.Backslash);

            case SDL.SDL_Keycode.SDLK_RIGHTBRACKET:
                return(Keys.RightBracket);

            case SDL.SDL_Keycode.SDLK_CARET:
                return(Keys.Caret);

            case SDL.SDL_Keycode.SDLK_UNDERSCORE:
                return(Keys.Underscore);

            case SDL.SDL_Keycode.SDLK_BACKQUOTE:
                return(Keys.BackQuote);

            case SDL.SDL_Keycode.SDLK_a:
                return(Keys.A);

            case SDL.SDL_Keycode.SDLK_b:
                return(Keys.B);

            case SDL.SDL_Keycode.SDLK_c:
                return(Keys.C);

            case SDL.SDL_Keycode.SDLK_d:
                return(Keys.D);

            case SDL.SDL_Keycode.SDLK_e:
                return(Keys.E);

            case SDL.SDL_Keycode.SDLK_f:
                return(Keys.F);

            case SDL.SDL_Keycode.SDLK_g:
                return(Keys.G);

            case SDL.SDL_Keycode.SDLK_h:
                return(Keys.H);

            case SDL.SDL_Keycode.SDLK_i:
                return(Keys.I);

            case SDL.SDL_Keycode.SDLK_j:
                return(Keys.J);

            case SDL.SDL_Keycode.SDLK_k:
                return(Keys.K);

            case SDL.SDL_Keycode.SDLK_l:
                return(Keys.L);

            case SDL.SDL_Keycode.SDLK_m:
                return(Keys.M);

            case SDL.SDL_Keycode.SDLK_n:
                return(Keys.N);

            case SDL.SDL_Keycode.SDLK_o:
                return(Keys.O);

            case SDL.SDL_Keycode.SDLK_p:
                return(Keys.P);

            case SDL.SDL_Keycode.SDLK_q:
                return(Keys.Q);

            case SDL.SDL_Keycode.SDLK_r:
                return(Keys.R);

            case SDL.SDL_Keycode.SDLK_s:
                return(Keys.S);

            case SDL.SDL_Keycode.SDLK_t:
                return(Keys.T);

            case SDL.SDL_Keycode.SDLK_u:
                return(Keys.U);

            case SDL.SDL_Keycode.SDLK_v:
                return(Keys.V);

            case SDL.SDL_Keycode.SDLK_w:
                return(Keys.W);

            case SDL.SDL_Keycode.SDLK_x:
                return(Keys.X);

            case SDL.SDL_Keycode.SDLK_y:
                return(Keys.Y);

            case SDL.SDL_Keycode.SDLK_z:
                return(Keys.Z);

            case SDL.SDL_Keycode.SDLK_CAPSLOCK:
                return(Keys.CapsLock);

            case SDL.SDL_Keycode.SDLK_F1:
                return(Keys.F1);

            case SDL.SDL_Keycode.SDLK_F2:
                return(Keys.F2);

            case SDL.SDL_Keycode.SDLK_F3:
                return(Keys.F3);

            case SDL.SDL_Keycode.SDLK_F4:
                return(Keys.F4);

            case SDL.SDL_Keycode.SDLK_F5:
                return(Keys.F5);

            case SDL.SDL_Keycode.SDLK_F6:
                return(Keys.F6);

            case SDL.SDL_Keycode.SDLK_F7:
                return(Keys.F7);

            case SDL.SDL_Keycode.SDLK_F8:
                return(Keys.F8);

            case SDL.SDL_Keycode.SDLK_F9:
                return(Keys.F9);

            case SDL.SDL_Keycode.SDLK_F10:
                return(Keys.F10);

            case SDL.SDL_Keycode.SDLK_F11:
                return(Keys.F11);

            case SDL.SDL_Keycode.SDLK_F12:
                return(Keys.F12);

            case SDL.SDL_Keycode.SDLK_PRINTSCREEN:
                return(Keys.PrintScreen);

            case SDL.SDL_Keycode.SDLK_SCROLLLOCK:
                return(Keys.ScrollLock);

            case SDL.SDL_Keycode.SDLK_PAUSE:
                return(Keys.Pause);

            case SDL.SDL_Keycode.SDLK_INSERT:
                return(Keys.Insert);

            case SDL.SDL_Keycode.SDLK_HOME:
                return(Keys.Home);

            case SDL.SDL_Keycode.SDLK_PAGEUP:
                return(Keys.PageUp);

            case SDL.SDL_Keycode.SDLK_DELETE:
                return(Keys.Delete);

            case SDL.SDL_Keycode.SDLK_END:
                return(Keys.End);

            case SDL.SDL_Keycode.SDLK_PAGEDOWN:
                return(Keys.PageDown);

            case SDL.SDL_Keycode.SDLK_RIGHT:
                return(Keys.Right);

            case SDL.SDL_Keycode.SDLK_LEFT:
                return(Keys.Left);

            case SDL.SDL_Keycode.SDLK_DOWN:
                return(Keys.Down);

            case SDL.SDL_Keycode.SDLK_UP:
                return(Keys.Up);

            case SDL.SDL_Keycode.SDLK_NUMLOCKCLEAR:
                return(Keys.NumLockClear);

            case SDL.SDL_Keycode.SDLK_KP_DIVIDE:
                return(Keys.KpDivide);

            case SDL.SDL_Keycode.SDLK_KP_MULTIPLY:
                return(Keys.KpMultiply);

            case SDL.SDL_Keycode.SDLK_KP_MINUS:
                return(Keys.KpMinus);

            case SDL.SDL_Keycode.SDLK_KP_PLUS:
                return(Keys.KpPlus);

            case SDL.SDL_Keycode.SDLK_KP_ENTER:
                return(Keys.KpEnter);

            case SDL.SDL_Keycode.SDLK_KP_1:
                return(Keys.Kp1);

            case SDL.SDL_Keycode.SDLK_KP_2:
                return(Keys.Kp2);

            case SDL.SDL_Keycode.SDLK_KP_3:
                return(Keys.Kp3);

            case SDL.SDL_Keycode.SDLK_KP_4:
                return(Keys.Kp4);

            case SDL.SDL_Keycode.SDLK_KP_5:
                return(Keys.Kp5);

            case SDL.SDL_Keycode.SDLK_KP_6:
                return(Keys.Kp6);

            case SDL.SDL_Keycode.SDLK_KP_7:
                return(Keys.Kp7);

            case SDL.SDL_Keycode.SDLK_KP_8:
                return(Keys.Kp8);

            case SDL.SDL_Keycode.SDLK_KP_9:
                return(Keys.Kp9);

            case SDL.SDL_Keycode.SDLK_KP_0:
                return(Keys.Kp0);

            case SDL.SDL_Keycode.SDLK_KP_PERIOD:
                return(Keys.KpPeriod);

            case SDL.SDL_Keycode.SDLK_APPLICATION:
                return(Keys.Application);

            case SDL.SDL_Keycode.SDLK_POWER:
                return(Keys.Power);

            case SDL.SDL_Keycode.SDLK_KP_EQUALS:
                return(Keys.KpEquals);

            case SDL.SDL_Keycode.SDLK_F13:
                return(Keys.F13);

            case SDL.SDL_Keycode.SDLK_F14:
                return(Keys.F14);

            case SDL.SDL_Keycode.SDLK_F15:
                return(Keys.F15);

            case SDL.SDL_Keycode.SDLK_F16:
                return(Keys.F16);

            case SDL.SDL_Keycode.SDLK_F17:
                return(Keys.F17);

            case SDL.SDL_Keycode.SDLK_F18:
                return(Keys.F18);

            case SDL.SDL_Keycode.SDLK_F19:
                return(Keys.F19);

            case SDL.SDL_Keycode.SDLK_F20:
                return(Keys.F20);

            case SDL.SDL_Keycode.SDLK_F21:
                return(Keys.F21);

            case SDL.SDL_Keycode.SDLK_F22:
                return(Keys.F22);

            case SDL.SDL_Keycode.SDLK_F23:
                return(Keys.F23);

            case SDL.SDL_Keycode.SDLK_F24:
                return(Keys.F24);

            case SDL.SDL_Keycode.SDLK_EXECUTE:
                return(Keys.Execute);

            case SDL.SDL_Keycode.SDLK_HELP:
                return(Keys.Help);

            case SDL.SDL_Keycode.SDLK_MENU:
                return(Keys.Menu);

            case SDL.SDL_Keycode.SDLK_SELECT:
                return(Keys.Select);

            case SDL.SDL_Keycode.SDLK_STOP:
                return(Keys.Stop);

            case SDL.SDL_Keycode.SDLK_AGAIN:
                return(Keys.Again);

            case SDL.SDL_Keycode.SDLK_UNDO:
                return(Keys.Undo);

            case SDL.SDL_Keycode.SDLK_CUT:
                return(Keys.Cut);

            case SDL.SDL_Keycode.SDLK_COPY:
                return(Keys.Copy);

            case SDL.SDL_Keycode.SDLK_PASTE:
                return(Keys.Paste);

            case SDL.SDL_Keycode.SDLK_FIND:
                return(Keys.Find);

            case SDL.SDL_Keycode.SDLK_MUTE:
                return(Keys.Mute);

            case SDL.SDL_Keycode.SDLK_VOLUMEUP:
                return(Keys.VolumeUp);

            case SDL.SDL_Keycode.SDLK_VOLUMEDOWN:
                return(Keys.VolumeDown);

            case SDL.SDL_Keycode.SDLK_KP_COMMA:
                return(Keys.KpComma);

            case SDL.SDL_Keycode.SDLK_KP_EQUALSAS400:
                return(Keys.KpEqualsAs400);

            case SDL.SDL_Keycode.SDLK_ALTERASE:
                return(Keys.Alterase);

            case SDL.SDL_Keycode.SDLK_SYSREQ:
                return(Keys.SysReq);

            case SDL.SDL_Keycode.SDLK_CANCEL:
                return(Keys.Cancel);

            case SDL.SDL_Keycode.SDLK_CLEAR:
                return(Keys.Clear);

            case SDL.SDL_Keycode.SDLK_PRIOR:
                return(Keys.Prior);

            case SDL.SDL_Keycode.SDLK_RETURN2:
                return(Keys.Return2);

            case SDL.SDL_Keycode.SDLK_SEPARATOR:
                return(Keys.Separator);

            case SDL.SDL_Keycode.SDLK_OUT:
                return(Keys.Out);

            case SDL.SDL_Keycode.SDLK_OPER:
                return(Keys.Oper);

            case SDL.SDL_Keycode.SDLK_CLEARAGAIN:
                return(Keys.ClearAgain);

            case SDL.SDL_Keycode.SDLK_CRSEL:
                return(Keys.CRSEL);

            case SDL.SDL_Keycode.SDLK_EXSEL:
                return(Keys.EXSEL);

            case SDL.SDL_Keycode.SDLK_KP_00:
                return(Keys.Kp00);

            case SDL.SDL_Keycode.SDLK_KP_000:
                return(Keys.Kp000);

            case SDL.SDL_Keycode.SDLK_THOUSANDSSEPARATOR:
                return(Keys.ThousandsSeparator);

            case SDL.SDL_Keycode.SDLK_DECIMALSEPARATOR:
                return(Keys.DecimalSeparator);

            case SDL.SDL_Keycode.SDLK_CURRENCYUNIT:
                return(Keys.CurrencyUnit);

            case SDL.SDL_Keycode.SDLK_CURRENCYSUBUNIT:
                return(Keys.CurrencySubUnit);

            case SDL.SDL_Keycode.SDLK_KP_LEFTPAREN:
                return(Keys.KpLeftParen);

            case SDL.SDL_Keycode.SDLK_KP_RIGHTPAREN:
                return(Keys.KpRightParen);

            case SDL.SDL_Keycode.SDLK_KP_LEFTBRACE:
                return(Keys.KpLeftBrace);

            case SDL.SDL_Keycode.SDLK_KP_RIGHTBRACE:
                return(Keys.KpRightBrace);

            case SDL.SDL_Keycode.SDLK_KP_TAB:
                return(Keys.KpTab);

            case SDL.SDL_Keycode.SDLK_KP_BACKSPACE:
                return(Keys.KpBackspace);

            case SDL.SDL_Keycode.SDLK_KP_A:
                return(Keys.KpA);

            case SDL.SDL_Keycode.SDLK_KP_B:
                return(Keys.KpB);

            case SDL.SDL_Keycode.SDLK_KP_C:
                return(Keys.KpC);

            case SDL.SDL_Keycode.SDLK_KP_D:
                return(Keys.KpD);

            case SDL.SDL_Keycode.SDLK_KP_E:
                return(Keys.KpE);

            case SDL.SDL_Keycode.SDLK_KP_F:
                return(Keys.KpF);

            case SDL.SDL_Keycode.SDLK_KP_XOR:
                return(Keys.KpXor);

            case SDL.SDL_Keycode.SDLK_KP_POWER:
                return(Keys.KpPower);

            case SDL.SDL_Keycode.SDLK_KP_PERCENT:
                return(Keys.KpPercent);

            case SDL.SDL_Keycode.SDLK_KP_LESS:
                return(Keys.KpLess);

            case SDL.SDL_Keycode.SDLK_KP_GREATER:
                return(Keys.KpGreater);

            case SDL.SDL_Keycode.SDLK_KP_AMPERSAND:
                return(Keys.KpAmpersand);

            case SDL.SDL_Keycode.SDLK_KP_DBLAMPERSAND:
                return(Keys.KpDoubleAmpersand);

            case SDL.SDL_Keycode.SDLK_KP_VERTICALBAR:
                return(Keys.KpVerticalBar);

            case SDL.SDL_Keycode.SDLK_KP_DBLVERTICALBAR:
                return(Keys.KpDoubleVerticalBar);

            case SDL.SDL_Keycode.SDLK_KP_COLON:
                return(Keys.KpColon);

            case SDL.SDL_Keycode.SDLK_KP_HASH:
                return(Keys.KpHash);

            case SDL.SDL_Keycode.SDLK_KP_SPACE:
                return(Keys.KpSpace);

            case SDL.SDL_Keycode.SDLK_KP_AT:
                return(Keys.KpAt);

            case SDL.SDL_Keycode.SDLK_KP_EXCLAM:
                return(Keys.KpExclam);

            case SDL.SDL_Keycode.SDLK_KP_MEMSTORE:
                return(Keys.KpMemStore);

            case SDL.SDL_Keycode.SDLK_KP_MEMRECALL:
                return(Keys.KpMemRecall);

            case SDL.SDL_Keycode.SDLK_KP_MEMCLEAR:
                return(Keys.KpMemClear);

            case SDL.SDL_Keycode.SDLK_KP_MEMADD:
                return(Keys.KpMemAdd);

            case SDL.SDL_Keycode.SDLK_KP_MEMSUBTRACT:
                return(Keys.KpMemSubtract);

            case SDL.SDL_Keycode.SDLK_KP_MEMMULTIPLY:
                return(Keys.KpMemMultiply);

            case SDL.SDL_Keycode.SDLK_KP_MEMDIVIDE:
                return(Keys.KpMemDivide);

            case SDL.SDL_Keycode.SDLK_KP_PLUSMINUS:
                return(Keys.KpPlusMinus);

            case SDL.SDL_Keycode.SDLK_KP_CLEAR:
                return(Keys.KpClear);

            case SDL.SDL_Keycode.SDLK_KP_CLEARENTRY:
                return(Keys.KpClearEntry);

            case SDL.SDL_Keycode.SDLK_KP_BINARY:
                return(Keys.KpBinary);

            case SDL.SDL_Keycode.SDLK_KP_OCTAL:
                return(Keys.KpOctal);

            case SDL.SDL_Keycode.SDLK_KP_DECIMAL:
                return(Keys.KpDecimal);

            case SDL.SDL_Keycode.SDLK_KP_HEXADECIMAL:
                return(Keys.KpHexadecimal);

            case SDL.SDL_Keycode.SDLK_LCTRL:
                return(Keys.LeftControl);

            case SDL.SDL_Keycode.SDLK_LSHIFT:
                return(Keys.LeftShift);

            case SDL.SDL_Keycode.SDLK_LALT:
                return(Keys.LeftAlt);

            case SDL.SDL_Keycode.SDLK_LGUI:
                return(Keys.LGUI);

            case SDL.SDL_Keycode.SDLK_RCTRL:
                return(Keys.RightControl);

            case SDL.SDL_Keycode.SDLK_RSHIFT:
                return(Keys.RightShift);

            case SDL.SDL_Keycode.SDLK_RALT:
                return(Keys.RightAlt);

            case SDL.SDL_Keycode.SDLK_RGUI:
                return(Keys.RGUI);

            case SDL.SDL_Keycode.SDLK_MODE:
                return(Keys.Mode);

            case SDL.SDL_Keycode.SDLK_AUDIONEXT:
                return(Keys.AudioNext);

            case SDL.SDL_Keycode.SDLK_AUDIOPREV:
                return(Keys.AudioPrev);

            case SDL.SDL_Keycode.SDLK_AUDIOSTOP:
                return(Keys.AudioStop);

            case SDL.SDL_Keycode.SDLK_AUDIOPLAY:
                return(Keys.AudioPlay);

            case SDL.SDL_Keycode.SDLK_AUDIOMUTE:
                return(Keys.AudioMute);

            case SDL.SDL_Keycode.SDLK_MEDIASELECT:
                return(Keys.MediaSelect);

            case SDL.SDL_Keycode.SDLK_WWW:
                return(Keys.Www);

            case SDL.SDL_Keycode.SDLK_MAIL:
                return(Keys.Mail);

            case SDL.SDL_Keycode.SDLK_CALCULATOR:
                return(Keys.Calculator);

            case SDL.SDL_Keycode.SDLK_COMPUTER:
                return(Keys.Computer);

            case SDL.SDL_Keycode.SDLK_AC_SEARCH:
                return(Keys.ActionSearch);

            case SDL.SDL_Keycode.SDLK_AC_HOME:
                return(Keys.ActionHome);

            case SDL.SDL_Keycode.SDLK_AC_BACK:
                return(Keys.ActionBack);

            case SDL.SDL_Keycode.SDLK_AC_FORWARD:
                return(Keys.ActionForward);

            case SDL.SDL_Keycode.SDLK_AC_STOP:
                return(Keys.ActionStop);

            case SDL.SDL_Keycode.SDLK_AC_REFRESH:
                return(Keys.ActionRefresh);

            case SDL.SDL_Keycode.SDLK_AC_BOOKMARKS:
                return(Keys.ActionBookmarks);

            case SDL.SDL_Keycode.SDLK_BRIGHTNESSDOWN:
                return(Keys.BrightnessDown);

            case SDL.SDL_Keycode.SDLK_BRIGHTNESSUP:
                return(Keys.BrightnessUp);

            case SDL.SDL_Keycode.SDLK_DISPLAYSWITCH:
                return(Keys.DisplaySwitch);

            case SDL.SDL_Keycode.SDLK_KBDILLUMTOGGLE:
                return(Keys.KBDILLUMTOGGLE);

            case SDL.SDL_Keycode.SDLK_KBDILLUMDOWN:
                return(Keys.KBDILLUMDOWN);

            case SDL.SDL_Keycode.SDLK_KBDILLUMUP:
                return(Keys.KBDILLUMUP);

            case SDL.SDL_Keycode.SDLK_EJECT:
                return(Keys.Eject);

            case SDL.SDL_Keycode.SDLK_SLEEP:
                return(Keys.Sleep);

            default:
                throw new ArgumentOutOfRangeException(nameof(keyCode), keyCode, null);
            }
        }