Exemplo n.º 1
0
        public override void Draw(SpriteBatch spriteBatch)
        {
            var offset = 11 + Index * (26 + (int)_font.MeasureString(Text.Value).X);

            if (GameProvider.GameInstance.GetService <InputSystem>().GamePad.IsConnected())
            {
                spriteBatch.Draw(GetTexture(), new Rectangle(offset, GameProvider.GameInstance.ScreenBounds.Height - 48, 32, 32), _highlightColor);
                offset += 32;
            }
            else
            {
                int    boxWidth      = 32;
                string displayString = KeyboardKey.ToString();

                if (_font.MeasureString(displayString).X + 10 > 32)
                {
                    boxWidth = (int)(_font.MeasureString(displayString).X + 10);
                }

                GameProvider.GameInstance.GetService <ShapeRenderer>().DrawRectangle(new Rectangle(offset, GameProvider.GameInstance.ScreenBounds.Height - 48, boxWidth, 32), _highlightColor, filled: false);
                spriteBatch.DrawString(_font, displayString, new Vector2(offset + 5, GameProvider.GameInstance.ScreenBounds.Height - 48), _highlightColor);

                offset += boxWidth;
            }

            spriteBatch.DrawString(_font, Text.Value, new Vector2(offset + 10, GameProvider.GameInstance.ScreenBounds.Height - 48), _highlightColor);
        }
Exemplo n.º 2
0
 public static string Pretty(this KeyboardKey key)
 {
     return(new Dictionary <KeyboardKey, string>()
     {
         { KeyboardKey.KEY_LEFT_CONTROL, "Ctrl" },
         { KeyboardKey.KEY_LEFT_SUPER, "Cmd" }
     }.GetValueOrDefault(key, key.ToString().Replace("KEY_", "")));
 }
Exemplo n.º 3
0
        public static char ToChar(this KeyboardKey key, bool uppercase = false)
        {
            if (!key.IsAcceptableInput(AcceptableKeyboardKeyFlags.Alphabetical | AcceptableKeyboardKeyFlags.Punctuation))
            {
                throw new Exception("given key is not alphabetical or punctuation");
            }

            switch (key)
            {
            case KeyboardKey.Space:
                return(' ');

            case KeyboardKey.Dash:
                return('-');

            case KeyboardKey.Apostrophe:
                return('\'');

            default:
                char chr = key.ToString()[0];
                return(uppercase ? chr : char.ToLower(chr));
            }
        }
Exemplo n.º 4
0
        /// <summary>
        /// Takes an input of a keyboard key and converts it
        /// to Unitys KeyCode variant.
        /// </summary>
        /// <param name="key">The keyboard key to convert.</param>
        /// <returns>The Unity keycode.</returns>
        public static KeyCode ToKeyCode(this KeyboardKey key)
        {
            switch (key)
            {
            case KeyboardKey.A:
                return(KeyCode.A);

            case KeyboardKey.B:
                return(KeyCode.B);

            case KeyboardKey.C:
                return(KeyCode.C);

            case KeyboardKey.D:
                return(KeyCode.D);

            case KeyboardKey.E:
                return(KeyCode.E);

            case KeyboardKey.F:
                return(KeyCode.F);

            case KeyboardKey.G:
                return(KeyCode.G);

            case KeyboardKey.H:
                return(KeyCode.H);

            case KeyboardKey.I:
                return(KeyCode.I);

            case KeyboardKey.J:
                return(KeyCode.J);

            case KeyboardKey.K:
                return(KeyCode.K);

            case KeyboardKey.L:
                return(KeyCode.L);

            case KeyboardKey.M:
                return(KeyCode.M);

            case KeyboardKey.N:
                return(KeyCode.N);

            case KeyboardKey.O:
                return(KeyCode.O);

            case KeyboardKey.P:
                return(KeyCode.P);

            case KeyboardKey.Q:
                return(KeyCode.Q);

            case KeyboardKey.R:
                return(KeyCode.R);

            case KeyboardKey.S:
                return(KeyCode.S);

            case KeyboardKey.T:
                return(KeyCode.T);

            case KeyboardKey.U:
                return(KeyCode.U);

            case KeyboardKey.V:
                return(KeyCode.V);

            case KeyboardKey.W:
                return(KeyCode.W);

            case KeyboardKey.X:
                return(KeyCode.X);

            case KeyboardKey.Y:
                return(KeyCode.Y);

            case KeyboardKey.Z:
                return(KeyCode.Z);

            case KeyboardKey.Alpha0:
                return(KeyCode.Alpha0);

            case KeyboardKey.Alpha1:
                return(KeyCode.Alpha1);

            case KeyboardKey.Alpha2:
                return(KeyCode.Alpha2);

            case KeyboardKey.Alpha3:
                return(KeyCode.Alpha3);

            case KeyboardKey.Alpha4:
                return(KeyCode.Alpha4);

            case KeyboardKey.Alpha5:
                return(KeyCode.Alpha5);

            case KeyboardKey.Alpha6:
                return(KeyCode.Alpha6);

            case KeyboardKey.Alpha7:
                return(KeyCode.Alpha7);

            case KeyboardKey.Alpha8:
                return(KeyCode.Alpha8);

            case KeyboardKey.Alpha9:
                return(KeyCode.Alpha9);

            case KeyboardKey.BackQuote:
                return(KeyCode.BackQuote);

            case KeyboardKey.ForwardQuote:
                return(KeyCode.Quote);

            case KeyboardKey.DoubleQuote:
                return(KeyCode.DoubleQuote);

            case KeyboardKey.Semicolon:
                return(KeyCode.Semicolon);

            case KeyboardKey.LeftBracket:
                return(KeyCode.LeftBracket);

            case KeyboardKey.RightBracket:
                return(KeyCode.RightBracket);

            case KeyboardKey.ForwardSlash:
                return(KeyCode.Slash);

            case KeyboardKey.BackSlash:
                return(KeyCode.Backslash);

            case KeyboardKey.LeftShift:
                return(KeyCode.LeftShift);

            case KeyboardKey.RightShift:
                return(KeyCode.RightShift);

            case KeyboardKey.LeftControl:
                return(KeyCode.LeftControl);

            case KeyboardKey.RightControl:
                return(KeyCode.RightControl);

            case KeyboardKey.LeftAlt:
                return(KeyCode.LeftAlt);

            case KeyboardKey.RightAlt:
                return(KeyCode.RightAlt);

            case KeyboardKey.CapsLock:
                return(KeyCode.CapsLock);

            case KeyboardKey.Tab:
                return(KeyCode.Tab);

            case KeyboardKey.AlphaEnter:
                return(KeyCode.Return);

            case KeyboardKey.Backspace:
                return(KeyCode.Backspace);

            case KeyboardKey.Delete:
                return(KeyCode.Delete);

            case KeyboardKey.Escape:
                return(KeyCode.Escape);

            case KeyboardKey.Insert:
                return(KeyCode.Insert);

            case KeyboardKey.Home:
                return(KeyCode.Home);

            case KeyboardKey.PageUp:
                return(KeyCode.PageUp);

            case KeyboardKey.PageDown:
                return(KeyCode.PageDown);

            case KeyboardKey.End:
                return(KeyCode.End);

            case KeyboardKey.UpArrow:
                return(KeyCode.UpArrow);

            case KeyboardKey.DownArrow:
                return(KeyCode.DownArrow);

            case KeyboardKey.LeftArrow:
                return(KeyCode.LeftArrow);

            case KeyboardKey.RightArrow:
                return(KeyCode.RightArrow);

            case KeyboardKey.Minus:
                return(KeyCode.Minus);

            case KeyboardKey.Plus:
                return(KeyCode.Plus);

            case KeyboardKey.Keypad0:
                return(KeyCode.Keypad0);

            case KeyboardKey.Keypad1:
                return(KeyCode.Keypad1);

            case KeyboardKey.Keypad2:
                return(KeyCode.Keypad2);

            case KeyboardKey.Keypad3:
                return(KeyCode.Keypad3);

            case KeyboardKey.Keypad4:
                return(KeyCode.Keypad4);

            case KeyboardKey.Keypad5:
                return(KeyCode.Keypad5);

            case KeyboardKey.Keypad6:
                return(KeyCode.Keypad6);

            case KeyboardKey.Keypad7:
                return(KeyCode.Keypad7);

            case KeyboardKey.Keypad8:
                return(KeyCode.Keypad8);

            case KeyboardKey.Keypad9:
                return(KeyCode.Keypad9);

            case KeyboardKey.KeypadEnter:
                return(KeyCode.KeypadEnter);

            case KeyboardKey.KeypadPlus:
                return(KeyCode.KeypadPlus);

            case KeyboardKey.KeypadMinus:
                return(KeyCode.KeypadMinus);

            case KeyboardKey.KeypadMultiply:
                return(KeyCode.KeypadMultiply);

            case KeyboardKey.KeypadDivide:
                return(KeyCode.KeypadDivide);

            case KeyboardKey.KeypadPeriod:
                return(KeyCode.KeypadPeriod);

            default:
                throw new NotSupportedException(string.Format("KeyboardKey: {0} is not supported.", key.ToString()));
            }
        }
Exemplo n.º 5
0
 public static KeyboardKeyComm Map(this KeyboardKey key)
 {
     Enum.TryParse(key.ToString(), out KeyboardKeyComm s);
     return(s);
 }
Exemplo n.º 6
0
 public static VirtualKeyCode Map(this KeyboardKey key)
 {
     Enum.TryParse(key.ToString(), out VirtualKeyCode k);
     return(k);
 }
Exemplo n.º 7
0
        public static string GetKeyContent(this KeyboardKey key, bool shift)
        {
            // Letters
            if ((int)key >= (int)KeyboardKey.A && (int)key <= (int)KeyboardKey.Z)
            {
                if (shift)
                {
                    return(key.ToString());
                }
                return(key.ToString().ToLower());
            }

            switch (key)
            {
            case KeyboardKey.Equal:
                return(shift ? "+" : "=");

            case KeyboardKey.Add:
                return("+");

            case KeyboardKey.Backslash:
                return(shift ? "|" : "\\");

            case KeyboardKey.Comma:
                return(shift ? "<" : ",");

            case KeyboardKey.Dash:
                return(shift ? "_" : "-");

            case KeyboardKey.Divide:
                return("/");

            case KeyboardKey.LBracket:
                return(shift ? "{" : "[");

            case KeyboardKey.Multiply:
                return("*");

            case KeyboardKey.Num0:
                return(shift ? ")" : "0");

            case KeyboardKey.Num1:
                return(shift ? "!" : "1");

            case KeyboardKey.Num2:
                return(shift ? "@" : "2");

            case KeyboardKey.Num3:
                return(shift ? "#" : "3");

            case KeyboardKey.Num4:
                return(shift ? "$" : "4");

            case KeyboardKey.Num5:
                return(shift ? "%" : "5");

            case KeyboardKey.Num6:
                return(shift ? "^" : "6");

            case KeyboardKey.Num7:
                return(shift ? "&" : "7");

            case KeyboardKey.Num8:
                return(shift ? "*" : "8");

            case KeyboardKey.Num9:
                return(shift ? "(" : "9");

            case KeyboardKey.Period:
                return(shift ? ">" : ".");

            case KeyboardKey.Quote:
                return(shift ? "\"" : "'");

            case KeyboardKey.RBracket:
                return(shift ? "}" : "]");

            case KeyboardKey.Semicolon:
                return(shift ? ":" : ";");

            case KeyboardKey.Slash:
                return(shift ? "?" : "/");

            case KeyboardKey.Subtract:
                return("-");

            case KeyboardKey.Tilde:
                return(shift ? "~" : "`");

            default:
                return(string.Empty);
            }
        }