Wie bestimmen Sie, ob ein Zeichen der Shift-Taste erfordert bis sein eingegeben werden?

Question

Ich schreibe einige Code-Strings eingeben, um den Roboter-Klasse. Alles ist meist gut (na ja, ich habe eine große switch-Anweisung verwenden Zeichen keycodes zu bekommen), außer einige Tasten nicht keycodes haben, weil sie eigentlich eine Kombination aus Umschalttaste + einem anderen Schlüssel sind. Für Großbuchstaben, ist es leicht Character.isUpperCase(c) zu überprüfen, zu verwenden, sondern auch für alle Symbole wie !@#$%^&*()_+ und verschiedene Interpunktion nicht „Großbuchstaben“ betrachtet, obwohl sie Verschiebung erfordern, um gedrückt werden thier Tastendruck zu erzeugen. Ich habe versucht, es googeln, fand aber nur einen Forenbeitrag ohne befriedigende Antworten. Gibt es eine Möglichkeit, um zu bestimmen, ob ein Zeichen Bedarf verschiebt gedrückt werden, und wenn ja, welche Zeichen ist die „un-verschoben“ -Version?

EDIT:. Hier ist der Code Ich habe so weit

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

Ich weiß nicht, einen Weg, um Ihr Problem zu lösen direkt (I endete nur für jene Zeichen, die eine Karte nach oben verwenden), aber es könnte Ihnen ein paar Ideen:

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

Ich bin nicht sicher, ob das, was Sie suchen möglich ist. Sie können Ihre eigene Tabelle erstellen, aber denken Sie daran, dass es dann nur für ein Tastaturlayout arbeiten werden (viele Sprachen ihre eigenen Tastaturlayouts, die für ihre spezifischen Zeichensätze besser geeignet sind, auch gibt es das Dvorak-Layout, das wahrscheinlich hat es own vs unverschobenen Schlüssel verschoben), wenn Sie berücksichtigen alle Tastaturlayouts Sie unterstützen möchten, und benutzerdefinierte Tabellen für diejenigen zu schaffen.

Answer 3

Können Sie AWT-Klassen verwenden? So etwas wie dies funktionieren könnte:

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

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

Answer 4

Wenn Sie auf der ASCII-Tabelle rel="nofollow diese Symboltasten befinden sich im Bereich 0x21 - 0x2B
Sie können sich wahrscheinlich in der ASCII-Tabelle sucht alle anderen Symbole zu erkennen.