Logo Questions Linux Laravel Mysql Ubuntu Git Menu
 

How to get pressed char from System.Windows.Input.KeyEventArgs?

I have System.Windows.Input.KeyEventArgs e variable. I want to get real char. For example, i press } button on keyboard. And normally it returns string like oem.. but i want to get } char. How to do ?

[EDIT] I use this in TextBox .

like image 830
Javidan Avatar asked Aug 18 '11 06:08

Javidan


3 Answers

See this post... how to capture the '#' character on different locale keyboards in WPF/C#?

it has a utility function called GetCharFromKey(Key key) which gets locale specific character from the Key of the Keyboard event args.

Very useful.

like image 69
WPF-it Avatar answered Nov 12 '22 04:11

WPF-it


Sometimes you just need to solved the problem with a sledgehammer.

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';
    }
}

Here's a more powerful version of the above code:

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
like image 8
Bimo Avatar answered Nov 12 '22 04:11

Bimo


You have e.Key property you can use for just that. Here's a link to msdn.

Edit:
I didn't realize you need the actual char. You can take a look here They say that in WPF you can do it using some Win32 APIs, while in Silverlight it seems rather difficult. Also you can look at KeyInterop.VirtualKeyFromKey - you can convert the WPF Key enum into a WinForms Keys enumeration, which does give you some more information. I haven't tried any of the solutions, so I don't know if any of them will work.
And one last thing. Why do you need the char from the KeyDown/Up event? Are you sure you can't use the TextChanged event instead? It will be much easier to get the exact char, if you can.

like image 1
Georgi Stoyanov Avatar answered Nov 12 '22 05:11

Georgi Stoyanov