¿Cómo se determina si un personaje requiere la tecla de mayúsculas a ser a ser escrito?

Question

Estoy escribiendo algo de código para escribir una cadena utilizando la clase del robot. Todo es sobre todo buena (bueno, tengo que utilizar una sentencia switch grande para obtener códigos de teclas de caracteres), excepto algunas teclas no tienen códigos de teclas, ya que son en realidad una combinación de Mayúsculas + alguna otra tecla. Para letras mayúsculas, es fácil comprobar, utilizando Character.isUpperCase(c), sino para todos los símbolos tales como !@#$%^&*()_+ y varios puntuacion no se consideran "mayúsculas" a pesar de que no se requiere cambio de ser presionado con el fin de generar emabrgo pulsación de tecla. He intentado googlear para ello, pero acabo de encontrar un mensaje en el foro sin respuestas satisfactorias. ¿Hay alguna manera de determinar si un carácter necesidades cambian al ser presionado, y si es así, ¿qué personaje es la versión "-un desplazado"?

EDIT:. Aquí está el código que tengo hasta ahora

public void GenerateKeyTyped(char c) {
    if (Character.isUpperCase(c)) {
        r.keyPress(KeyEvent.VK_SHIFT);
    }
    r.keyPress(GetKeyCode(c));
    r.keyRelease(GetKeyCode(c));
    if (Character.isUpperCase(c)) {
        r.keyRelease(KeyEvent.VK_SHIFT);
    }
}

Answer 1

No conozco una manera de resolver el problema de manera directa (acabo terminó usando un mapa para aquellos caracteres) pero podría darle algunas ideas:

import java.io.*;
import java.util.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class Main3 {

    public static void main(String[] args) {
        try {
            Robot robot = new Robot();

            HashMap<String, String> map = new HashMap<String, String>();
            map.put("!", "1");
            map.put("@", "2");
            map.put("#", "3");

            char[] charz = "abcdefgABCDEFG123!#".toCharArray();

            for(int i = 0; i < charz.length; i++)
            {
                System.out.print(charz[i] + " : ");
                boolean shiftRequired = false;
                String key = String.valueOf(charz[i]);
                String value = map.get(key);

                if (value != null)
                {
                    shiftRequired = true;
                    key = value;
                }
                else if (Character.isUpperCase(key.charAt(0)))
                {
                    shiftRequired = true;
                }
                else
                {
                    key = key.toUpperCase();
                }

                KeyStroke ks = KeyStroke.getKeyStroke("pressed " + key.toUpperCase());

                int keyCode = ks.getKeyCode();
                System.out.println(keyCode);

                if (shiftRequired)
                    robot.keyPress(java.awt.event.KeyEvent.VK_SHIFT);

                robot.keyPress( keyCode );
                robot.keyRelease( keyCode );

                if (shiftRequired)
                    robot.keyRelease(java.awt.event.KeyEvent.VK_SHIFT);
            }


        } catch(Exception e) {
            e.printStackTrace();
        }
    }
}

Answer 2

No estoy seguro de si lo que estás buscando es posible. Usted puede crear su propia mesa, pero tenga en cuenta que luego va a trabajar para una sola disposición del teclado (muchos idiomas tienen sus propios diseños de teclado que son más adecuadas para sus conjuntos de caracteres específicos, también, está la distribución Dvorak, que probablemente tiene su propia desplazado vs llaves sin desplazar) a menos que tome en cuenta todas las disposiciones de teclado que desea apoyar, y crear tablas personalizadas para aquellos.

Answer 3

¿Se puede utilizar clases AWT? Algo como esto podría funcionar:

AWTKeyStroke ks = AWTKeyStroke.getAWTKeyStroke('!');
int modifers = ks.getModifiers();

if ((modifiers & KeyEvent.VK_SHIFT) == KeyEvent.VK_SHIFT) {
    // Shift pressed
}

Answer 4

Si nos fijamos en la estas teclas de símbolos se encuentran en el rango 0x21 - 0x2B
Probablemente se puede mirar la tabla ASCII para el reconocimiento de todos los otros símbolos.