Как получить нажатый char из системы.Окна.Вход.KeyEventArgs?

Я System.Windows.Input.KeyEventArgs переменной e. Я хочу получить настоящий шар. Например, я нажимаю на клавиатуре. И обычно он возвращает строку типа oem.. но я хочу сделать } char. Как это сделать ?

[EDIT] я использую это в текстовом поле .

5 ответов


посмотреть этот пост... Как захватить символ " # " на разных языковых клавиатурах в WPF/C#?

Он имеет вспомогательную функцию GetCharFromKey(Key key) который получает специфический символ локали от ключа args события клавиатуры.

очень полезно.


иногда вам просто нужно решить проблему с помощью кувалды.

char KeyToChar(Key key) {

    if (Keyboard.IsKeyDown(Key.LeftAlt)  ||
        Keyboard.IsKeyDown(Key.RightAlt) ||
        Keyboard.IsKeyDown(Key.LeftCtrl) ||
        Keyboard.IsKeyDown(Key.RightAlt))
    {
        return '\x00';
    }

    bool caplock  = Console.CapsLock;
    bool shift    = Keyboard.IsKeyDown(Key.LeftShift) || 
                            Keyboard.IsKeyDown(Key.RightShift);
    bool iscap    = (caplock && !shift) || (!caplock && shift);

        switch(key) {
            case Key.Enter:           return '\n';
            case Key.A:               return (iscap ? 'A' : 'a');
            case Key.B:               return (iscap ? 'B' : 'b');
            case Key.C:               return (iscap ? 'C' : 'c');
            case Key.D:               return (iscap ? 'D' : 'd');
            case Key.E:               return (iscap ? 'E' : 'e');
            case Key.F:               return (iscap ? 'F' : 'f');
            case Key.G:               return (iscap ? 'G' : 'g');
            case Key.H:               return (iscap ? 'H' : 'h');
            case Key.I:               return (iscap ? 'I' : 'i');
            case Key.J:               return (iscap ? 'J' : 'j');
            case Key.K:               return (iscap ? 'K' : 'k');
            case Key.L:               return (iscap ? 'L' : 'l');
            case Key.M:               return (iscap ? 'M' : 'm');
            case Key.N:               return (iscap ? 'N' : 'n');
            case Key.O:               return (iscap ? 'O' : 'o');
            case Key.P:               return (iscap ? 'P' : 'p');
            case Key.Q:               return (iscap ? 'Q' : 'q');
            case Key.R:               return (iscap ? 'R' : 'r');
            case Key.S:               return (iscap ? 'S' : 's');
            case Key.T:               return (iscap ? 'T' : 't');
            case Key.U:               return (iscap ? 'U' : 'u');
            case Key.V:               return (iscap ? 'V' : 'v');
            case Key.W:               return (iscap ? 'W' : 'w');
            case Key.X:               return (iscap ? 'X' : 'x');
            case Key.Y:               return (iscap ? 'Y' : 'y');
            case Key.Z:               return (iscap ? 'Z' : 'z');
            case Key.D0:              return (shift ? ')' : '0');
            case Key.D1:              return (shift ? '!' : '1');
            case Key.D2:              return (shift ? '@' : '2');
            case Key.D3:              return (shift ? '#' : '3');
            case Key.D4:              return (shift ? '$' : '4');
            case Key.D5:              return (shift ? '%' : '5');
            case Key.D6:              return (shift ? '^' : '6');
            case Key.D7:              return (shift ? '&' : '7');
            case Key.D8:              return (shift ? '*' : '8');
            case Key.D9:              return (shift ? '(' : '9');
            case Key.OemPlus:         return (shift ? '+' : '=');
            case Key.OemMinus:        return (shift ? '_' : '-');
            case Key.OemQuestion:     return (shift ? '?' : '/');
            case Key.OemComma:        return (shift ? '<' : ',');
            case Key.OemPeriod:       return (shift ? '>' : '.');
            case Key.OemOpenBrackets: return (shift ? '{' : '[');
            case Key.OemQuotes:       return (shift ? '"' : '\'');
            case Key.Oem1:            return (shift ? ':' : ';');
            case Key.Oem3:            return (shift ? '~' : '`');                   
            case Key.Oem5:            return (shift ? '|' : '\');
            case Key.Oem6:            return (shift ? '}' : ']');
            case Key.Tab:             return '\t';
            case Key.Space:           return ' ';

            // Number Pad
            case Key.NumPad0:         return '0';
            case Key.NumPad1:         return '1';
            case Key.NumPad2:         return '2';
            case Key.NumPad3:         return '3';
            case Key.NumPad4:         return '4';
            case Key.NumPad5:         return '5';
            case Key.NumPad6:         return '6';
            case Key.NumPad7:         return '7';
            case Key.NumPad8:         return '8';
            case Key.NumPad9:         return '9';
            case Key.Subtract:        return '-';
            case Key.Add:             return '+';
            case Key.Decimal:         return '.';
            case Key.Divide:          return '/';
            case Key.Multiply:        return '*';

            default:                  return '\x00';
    }
}

вот более мощная версия вышеуказанной код:

public struct IoCmd_t {
    public Key    key;
    public bool   printable;
    public char   character;
    public bool   shift;
    public bool   ctrl;
    public bool   alt;
    public int    type; //sideband
    public string s;    //sideband
};

public void KeyToChar(Key key, ref IoCmd_t KeyDecode) {
    bool iscap;
    bool caplock;
    bool shift;

    KeyDecode.key   = key;

    KeyDecode.alt   = Keyboard.IsKeyDown(Key.LeftAlt) || 
                      Keyboard.IsKeyDown(Key.RightAlt);

    KeyDecode.ctrl  = Keyboard.IsKeyDown(Key.LeftCtrl) ||
                      Keyboard.IsKeyDown(Key.RightCtrl);

    KeyDecode.shift = Keyboard.IsKeyDown(Key.LeftShift) ||
                      Keyboard.IsKeyDown(Key.RightShift);

    if (KeyDecode.alt || KeyDecode.ctrl) {
        KeyDecode.printable = false;                
        KeyDecode.type      = 1;                
    }
    else {
        KeyDecode.printable = true;
        KeyDecode.type      = 0;
    }

    shift    = KeyDecode.shift;
    caplock  = Console.CapsLock; //Keyboard.IsKeyToggled(Key.CapsLock);
    iscap    = (caplock && !shift) || (!caplock && shift);

    switch(key) {
        case Key.Enter:           KeyDecode.character = '\n'; return;
        case Key.A:               KeyDecode.character = (iscap ? 'A' : 'a');  return;
        case Key.B:               KeyDecode.character = (iscap ? 'B' : 'b');  return;
        case Key.C:               KeyDecode.character = (iscap ? 'C' : 'c');  return;
        case Key.D:               KeyDecode.character = (iscap ? 'D' : 'd');  return;
        case Key.E:               KeyDecode.character = (iscap ? 'E' : 'e');  return;
        case Key.F:               KeyDecode.character = (iscap ? 'F' : 'f');  return;
        case Key.G:               KeyDecode.character = (iscap ? 'G' : 'g');  return;
        case Key.H:               KeyDecode.character = (iscap ? 'H' : 'h');  return;
        case Key.I:               KeyDecode.character = (iscap ? 'I' : 'i');  return;
        case Key.J:               KeyDecode.character = (iscap ? 'J' : 'j');  return;
        case Key.K:               KeyDecode.character = (iscap ? 'K' : 'k');  return;
        case Key.L:               KeyDecode.character = (iscap ? 'L' : 'l');  return;
        case Key.M:               KeyDecode.character = (iscap ? 'M' : 'm');  return;
        case Key.N:               KeyDecode.character = (iscap ? 'N' : 'n');  return;
        case Key.O:               KeyDecode.character = (iscap ? 'O' : 'o');  return;
        case Key.P:               KeyDecode.character = (iscap ? 'P' : 'p');  return;
        case Key.Q:               KeyDecode.character = (iscap ? 'Q' : 'q');  return;
        case Key.R:               KeyDecode.character = (iscap ? 'R' : 'r');  return;
        case Key.S:               KeyDecode.character = (iscap ? 'S' : 's');  return;
        case Key.T:               KeyDecode.character = (iscap ? 'T' : 't');  return;
        case Key.U:               KeyDecode.character = (iscap ? 'U' : 'u');  return;
        case Key.V:               KeyDecode.character = (iscap ? 'V' : 'v');  return;
        case Key.W:               KeyDecode.character = (iscap ? 'W' : 'w');  return;
        case Key.X:               KeyDecode.character = (iscap ? 'X' : 'x');  return;
        case Key.Y:               KeyDecode.character = (iscap ? 'Y' : 'y');  return;
        case Key.Z:               KeyDecode.character = (iscap ? 'Z' : 'z');  return;
        case Key.D0:              KeyDecode.character = (shift ? ')' : '0');  return;
        case Key.D1:              KeyDecode.character = (shift ? '!' : '1');  return;
        case Key.D2:              KeyDecode.character = (shift ? '@' : '2');  return;
        case Key.D3:              KeyDecode.character = (shift ? '#' : '3');  return;
        case Key.D4:              KeyDecode.character = (shift ? '$' : '4');  return;
        case Key.D5:              KeyDecode.character = (shift ? '%' : '5');  return;
        case Key.D6:              KeyDecode.character = (shift ? '^' : '6');  return;
        case Key.D7:              KeyDecode.character = (shift ? '&' : '7');  return;
        case Key.D8:              KeyDecode.character = (shift ? '*' : '8');  return;
        case Key.D9:              KeyDecode.character = (shift ? '(' : '9');  return;
        case Key.OemPlus:         KeyDecode.character = (shift ? '+' : '=');  return;
        case Key.OemMinus:        KeyDecode.character = (shift ? '_' : '-');  return;
        case Key.OemQuestion:     KeyDecode.character = (shift ? '?' : '/');  return;
        case Key.OemComma:        KeyDecode.character = (shift ? '<' : ',');  return;
        case Key.OemPeriod:       KeyDecode.character = (shift ? '>' : '.');  return;
        case Key.OemOpenBrackets: KeyDecode.character = (shift ? '{' : '[');  return;
        case Key.OemQuotes:       KeyDecode.character = (shift ? '"' : '\''); return;
        case Key.Oem1:            KeyDecode.character = (shift ? ':' : ';');  return;
        case Key.Oem3:            KeyDecode.character = (shift ? '~' : '`');  return;
        case Key.Oem5:            KeyDecode.character = (shift ? '|' : '\'); return;
        case Key.Oem6:            KeyDecode.character = (shift ? '}' : ']');  return;
        case Key.Tab:             KeyDecode.character = '\t'; return;
        case Key.Space:           KeyDecode.character = ' '; return;

        // Number Pad
        case Key.NumPad0:         KeyDecode.character = '0'; return;
        case Key.NumPad1:         KeyDecode.character = '1'; return;
        case Key.NumPad2:         KeyDecode.character = '2'; return;
        case Key.NumPad3:         KeyDecode.character = '3'; return;
        case Key.NumPad4:         KeyDecode.character = '4'; return;
        case Key.NumPad5:         KeyDecode.character = '5'; return;
        case Key.NumPad6:         KeyDecode.character = '6'; return;
        case Key.NumPad7:         KeyDecode.character = '7'; return;
        case Key.NumPad8:         KeyDecode.character = '8'; return;
        case Key.NumPad9:         KeyDecode.character = '9'; return;
        case Key.Subtract:        KeyDecode.character = '-'; return;
        case Key.Add:             KeyDecode.character = '+'; return;
        case Key.Decimal:         KeyDecode.character = '.'; return;
        case Key.Divide:          KeyDecode.character = '/'; return;
        case Key.Multiply:        KeyDecode.character = '*'; return;

        default:
            KeyDecode.type      = 1;
            KeyDecode.printable = false;
            KeyDecode.character = '\x00'; 
            return;
    } //switch          
} // function

У вас есть e.Ключевое свойство, которое вы можете использовать именно для этого. Вот ссылка на msdn.

Edit:
Я не знал, что тебе нужен настоящий шар. Вы можете посмотреть здесь говорят, что в WPF вы можете сделать это с помощью некоторых Win32 API, в то время как в Silverlight это кажется довольно сложным. Также вы можете посмотреть на KeyInterop.VirtualKeyFromKey - вы можете преобразовать перечисление ключей WPF в перечисление ключей WinForms, которое дает вам еще несколько информация. Я не пробовал ни одного из решений, поэтому я не знаю, будет ли какой-либо из них работать.
И последнее. Зачем вам нужен символ из события KeyDown/Up? Вы уверены, что не можете использовать событие TextChanged вместо этого? Будет гораздо легче получить точный char, если вы можете.


вам нужно сделать эту обработку в событии нажатия клавиши, а не KeyDown или KeyUp. KeyEventArgs сказать, какой фактический ключ был нажат, а не соответствующий символ. Некоторые из ключей события не имеют связанного символа. Однако KeyPressEventArgs будет иметь связанный символ, потому что событие KeyPress не запускается для символьных клавиш (ctrl, up и т. д.)


char c = (char)e.KeyValue;

это вернет нажатую клавишу в виде заглавной буквы или числа это не будет работать со специальными символами