Comment déterminez-vous si un caractère nécessite que la touche Majuscule soit enfoncée pour être tapée?

Question

J'écris du code pour taper des chaînes en utilisant la classe Robot. Tout est bon pour la plupart (enfin, je dois utiliser une grosse instruction switch pour obtenir les keycodes), sauf que certaines touches n'ont pas de keycodes, car elles sont en réalité une combinaison de Shift + une autre touche. Pour les lettres majuscules, il est facile de vérifier, en utilisant Character.isUpperCase(c), mais pour tous les symboles tels que !@#$%^&*()_+ et diverses ponctuations ne sont pas considérées comme des majuscules, bien qu'elles nécessitent un décalage pour être pressées afin de générer leur touche. J'ai essayé de googler pour cela, mais je viens de trouver un message sur le forum sans réponses satisfaisantes. Y a-t-il un moyen de déterminer si un personnage a besoin d'un décalage pour être pressé, et si oui, quel caractère est la version "non décalée"?

EDIT: Voici le code que j'ai jusqu'à présent.

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

Je ne sais pas un moyen de résoudre votre problème directement (je viens fini par utiliser une carte pour les personnages), mais il peut vous donner quelques idées:

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

Si vous regardez le ASCII table ces touches de symboles sont situés dans la gamme 0x21 - 0x2B
Vous pouvez probablement voir à la table ASCII pour reconnaître tous vos autres symboles.

Answer 3

Je ne sais pas si ce que vous cherchez est possible. Vous pouvez créer votre propre table, mais gardez à l'esprit que cela ne fonctionnera que pour une seule disposition de clavier (beaucoup de langues ont leurs propres dispositions de clavier qui conviennent mieux à leurs jeux de caractères spécifiques, aussi, la disposition Dvorak a probablement propres touches décalées ou non décalées) sauf si vous prenez en compte toutes les dispositions de clavier que vous souhaitez prendre en charge et créez des tables personnalisées pour celles-ci.

Answer 4

Pouvez-vous utiliser les classes AWT? Quelque chose comme cela pourrait fonctionner:

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

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