Come si determina se un personaggio richiede il tasto shift per essere giù a essere digitato?

Question

Sto scrivendo un codice da digitare stringhe utilizzando la classe di robot. Tutto ciò che è per lo più buono (beh, devo usare una grande dichiarazione switch per ottenere keycodes carattere), ad eccezione di alcuni tasti non hanno keycodes, perché sono in realtà una combinazione di Maiusc + qualche altro tasto. Per le lettere maiuscole, è facile verificare, utilizzando Character.isUpperCase(c), ma per tutti i simboli come !@#$%^&*()_+ e vari punteggiatura non sono considerati "maiuscola", anche se richiedono spostamento da premere per generare maniche battitura. Ho provato googling per questo, ma appena trovato un post sul forum con risposte soddisfacenti. Esiste un modo per determinare se un carattere esigenze spostano da pressare, e in caso affermativo, quale carattere è la versione "non-spostato"?

EDIT:. Ecco il codice che ho finora

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

Non so un modo per risolvere direttamente il problema (ho appena finito per usare una mappa per quei caratteri) ma potrebbe darvi alcune idee:

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

Non sono sicuro se quello che stai cercando è possibile. Si potrebbe creare il proprio tavolo, ma tenere a mente che sarà poi lavorare per un solo layout di tastiera (molte lingue hanno i loro layout di tastiera che sono più adatti per i loro set di caratteri specifici, anche, c'è il layout Dvorak che, probabilmente, ha la sua proprio spostato vs chiavi unshifted) a meno che non si prende in considerazione tutti i layout di tastiera che si desidera supportare e creare tabelle personalizzate per quelli.

Answer 3

Si può utilizzare le classi AWT? Qualcosa di simile potrebbe funzionare:

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

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

Answer 4

Se si guarda alla questi tasti di simboli si trovano nella gamma 0x21 - 0x2B
Probabilmente si può guardare la tabella ASCII per il riconoscimento di tutti gli altri simboli.