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 .
How to get pressed char from System.Windows.Input.KeyEventArgs?
Asked Answered
This might help you: #544641 –
Bolometer
I checked this.but there is nothing to get real char. –
Tryst
Since as per msdn.microsoft.com/en-us/library/ms604577.aspx System.Windows.Input is used in WPF, re tagged the post. –
Reiche
I cannot explain you,i need char but there is no feature to get char.I use textBox –
Tryst
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.
Do we seriously still have to do this in 2018? It would've been great if C#/.NET provided utility functions to get the actual character pressed.. –
Veach
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
This only works for an american keyboard layout. With a german for example, it does not, because nearly all special signs are different. –
Riha
@Riha Looks like you have to write Vorschlaghammer instead of sledgehammer :) –
Dropforge
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.
i searched more,but didnt find anyting to return real char. –
Tryst
Here is a more modern approach:
private void Form1_KeyDown(object sender, KeyEventArgs e)
{
var theKeyAsAString = e.KeyCode.ToString();
var theKeyAsAChar = Convert.ToChar(theKeyAsAString);
}
Doesn't work, you're looking at the KeyEventArgs of another namespace. –
Toombs
Maybe an aproach with the "PreviewTextInput" event is easier here to get a clear char. you can assign a method like that to the event:
textbox_previewTextInput(object sender, TextCompositionEventArgs e){
var theChar = Convert.ToChar(e.Text);
if (theChar.Equals('{'))
{
// Do something with the char
e.Handled = true;
}
else
{
e.Handled = false;
}
}
I have not tested the code. But it should check all inputs made in the TextBox before the key pressed is added to the TextBoxs Text property.
In this example a '{' will not be added to the Text. As soon as you set e.Handled to false the pressed key will be added to the Text.
The variable theChar will always show the Letter you pressed. You do not need to evaluate if "shift", "control", ... was pressed. If you type an 'A' there will be an 'A' in the variable.
I think keyboard layout shouldn't be a problem either.
You need to do that processing in the KeyPress event, not KeyDown or KeyUp. KeyEventArgs tell which actual key was pressed, not the corresponding character. Some of the keys don't event have an associated character. However KeyPressEventArgs will have an associated character because KeyPress event is not fired for characterless keys (ctrl, up, etc)
this event doesnt exist in TextBox –
Tryst
char c = (char)e.KeyValue;
this will return the pressed key as a capital letter or a Number this will not work with special chars
The question author specifically gives
} as a use-case, so I don't think this answer is suitable for him. –
Acidimetry © 2022 - 2024 — McMap. All rights reserved.