C# ¿Cómo traducir el código clave virtual a char?

Question

Estoy tratando de asignar un código clave virtual a un char.

Mi código usa ProcessCmdKey para escuchar WM_KEYDOWN que me da acceso a la tecla presionada. Por ejemplo, cuando presiono una comilla simple obtengo una clave de 222 que quiero que se asigne a keychar 39, que representa ... lo adivinaste ... comilla simple.

Mi contexto dev es: - NET Framework 2.0 - control de usuario se coloca en un montón de lugares

¿Sabe usted la respuesta a la pregunta?

Answer 1

Sí, utilicé el método MapVirtualKey. Pero esperaba más detalles sobre cómo usarlo: qué directiva DllImport usar, qué enum es específico para mapear caracteres, etc.

No me gustan estas respuestas en las que hace google como 5 segundos y luego solo sugiera una solución: el verdadero desafío es juntar todas las piezas y no perder el tiempo con toneladas de páginas MSDN sin muestra u otros foros de codificación para obtener su respuesta. Sin fundamento ofensivo, pero tu respuesta (incluso buena) no tuvo problemas ya que tenía esta respuesta incluso antes de publicar mi pregunta en el foro.

Y esto es todo, voy a publicar lo que estaba buscando - una solución out-of-the-box C#:

1- Coloque esta directiva dentro de su clase:

[DllImport("user32.dll")] 
static extern int MapVirtualKey(uint uCode, uint uMapType); 

2- Recuperar a tu personaje como este:

protected override bool ProcessCmdKey(ref Message msg, Keys keyData)  
    { 
    const int WM_KEYDOWN = 0x100; 

    if (msg.Msg == WM_KEYDOWN) 
    {    
     // 2 is used to translate into an unshifted character value 
     int nonVirtualKey = MapVirtualKey((uint)keyData, 2); 

     char mappedChar = Convert.ToChar(nonVirtualKey); 
    } 

    return base.ProcessCmdKey(ref msg, keyData); 
    } 

Gracias por cuidar ... y disfrutar!

Answer 2

¿No es eso para lo que es la clase System.Windows.Form.KeysConverter?

KeysConverter kc = new KeysConverter(); 
string keyChar = kc.ConvertToString(keyData); 

Answer 3

KeysConverter recibe el nombre de clave no las teclas de "texto" ex: "Num2" en lugar de "2" MapVirtualKey funcionarán para Inglés, pero para no ingleses estados de documentación caracteres utilizando MapVirtualKeyEx pero que requiere un local identificador ese identificador es cargado por LoadKeyboardLayout que requiere una identificación de la cultura constante pero luego después de encontrar los valores de id correctas no funcionó como lo intenté así que finalmente me deshice de todo el asunto

Answer 4

después de leer y probar algunas de las respuestas proporcionadas, pensé que sugeriría una alternativa.

Como se menciona en MM, System.Windows.KeysConverter no proporciona una representación de caracteres de la clave sino el nombre de la enumeración, p. "Ingresar" en lugar de "\ n".

El método MapVirtualKey sugerido por Horas, en respuesta a su propia pregunta, es un buen punto de partida, pero aún no admite capslo o los caracteres ingresados ​​con la tecla Mayús, p. '!', '$' y '>'.

Una alternativa al método MapVirtualKey, que estoy usando, es un método de extensión para la clase Teclas:

public static char ToChar(this Keys key) 
{ 
    char c = '\0'; 
    if((key >= Keys.A) && (key <= Keys.Z)) 
    { 
     c = (char)((int)'a' + (int)(key - Keys.A)); 
    } 

    else if((key >= Keys.D0) && (key <= Keys.D9)) 
    { 
     c = (char)((int)'0' + (int)(key - Keys.D0)); 
    } 

    return c; 
} 

el método mostrado anteriormente proporcionará soporte para caracteres alfanuméricos. El soporte para caracteres adicionales podría implementarse con una instrucción switch o una tabla de búsqueda.

Answer 5

que estaba buscando algo similar pero que necesitaba el personaje asignado a la disposición del teclado actual. Como ninguna de las respuestas anteriores cumplió con mis requisitos, esto es lo que se me ocurrió.

     public string KeyCodeToUnicode(Keys key) 
     { 
      byte[] keyboardState = new byte[255]; 
      bool keyboardStateStatus = GetKeyboardState(keyboardState); 

      if (!keyboardStateStatus) 
      { 
       return ""; 
      } 

      uint virtualKeyCode = (uint)key; 
      uint scanCode = MapVirtualKey(virtualKeyCode, 0); 
      IntPtr inputLocaleIdentifier = GetKeyboardLayout(0); 

      StringBuilder result = new StringBuilder(); 
      ToUnicodeEx(virtualKeyCode, scanCode, keyboardState, result, (int)5, (uint)0, inputLocaleIdentifier); 

      return result.ToString(); 
     } 

     [DllImport("user32.dll")] 
     static extern bool GetKeyboardState(byte[] lpKeyState); 

     [DllImport("user32.dll")] 
     static extern uint MapVirtualKey(uint uCode, uint uMapType); 

     [DllImport("user32.dll")] 
     static extern IntPtr GetKeyboardLayout(uint idThread); 

     [DllImport("user32.dll")] 
     static extern int ToUnicodeEx(uint wVirtKey, uint wScanCode, byte[] lpKeyState, [Out, MarshalAs(UnmanagedType.LPWStr)] StringBuilder pwszBuff, int cchBuff, uint wFlags, IntPtr dwhkl); 

Answer 6

acabo de escribir una mejora de Ivan Petrov answer para mostrar una representación de cadena de combinaciones de teclas pulsadas en WPF, vea mi código de abajo:

public static string GetKeyString(Key key, ModifierKeys modifiers) 
{ 
    string result = ""; 
    if (key != Key.None) 
    { 
     // Setup modifiers 
     if (modifiers.HasFlag(ModifierKeys.Control)) 
      result += "Ctrl + "; 
     if (modifiers.HasFlag(ModifierKeys.Alt)) 
      result += "Alt + "; 
     if (modifiers.HasFlag(ModifierKeys.Shift)) 
      result += "Shift + "; 
     // Get string representation 
     string keyStr = key.ToString(); 
     int keyInt = (int)key; 
     // Numeric keys are returned without the 'D' 
     if (key >= Key.D0 && key <= Key.D9) 
      keyStr = char.ToString((char)(key - Key.D0 + '0')); 
     // Char keys are returned directly 
     else if (key >= Key.A && key <= Key.Z) 
      keyStr = char.ToString((char)(key - Key.A + 'A')); 
     // If the key is a keypad operation (Add, Multiply, ...) or an 'Oem' key, P/Invoke 
     else if ((keyInt >= 84 && keyInt <= 89) || keyInt >= 140) 
      keyStr = KeyCodeToUnicode(key); 
     result += keyStr; 
    } 
    return result; 
} 

private static string KeyCodeToUnicode(Key key) 
{ 
    byte[] keyboardState = new byte[255]; 
    bool keyboardStateStatus = GetKeyboardState(keyboardState); 

    if (!keyboardStateStatus) 
    { 
     return ""; 
    } 

    uint virtualKeyCode = (uint)KeyInterop.VirtualKeyFromKey(key); 
    uint scanCode = MapVirtualKey(virtualKeyCode, 0); 
    IntPtr inputLocaleIdentifier = GetKeyboardLayout(0); 

    StringBuilder result = new StringBuilder(); 
    ToUnicodeEx(virtualKeyCode, scanCode, new byte[255], result, (int)5, (uint)0, inputLocaleIdentifier); 

    return result.ToString(); 
} 

[DllImport("user32.dll")] 
static extern bool GetKeyboardState(byte[] lpKeyState); 

[DllImport("user32.dll")] 
static extern uint MapVirtualKey(uint uCode, uint uMapType); 

[DllImport("user32.dll")] 
static extern IntPtr GetKeyboardLayout(uint idThread); 

[DllImport("user32.dll")] 
static extern int ToUnicodeEx(uint wVirtKey, uint wScanCode, byte[] lpKeyState, [Out, MarshalAs(UnmanagedType.LPWStr)] StringBuilder pwszBuff, int cchBuff, uint wFlags, IntPtr dwhkl);