Como você determina se um personagem requer a tecla shift para ser baixo para ser digitado?

StackOverflow https://stackoverflow.com/questions/1101625

  •  12-09-2019
  •  | 
  •  

Pergunta

Estou a escrever algum código para cadeias tipo usando a classe Robot. Tudo é principalmente bom (bem, eu tenho que usar uma instrução switch grande para obter códigos de tecla de caracteres), com excepção de algumas teclas não têm keycodes, porque eles são realmente uma combinação de Mudança + alguma outra chave. Para letras maiúsculas, é fácil de verificar, utilizando Character.isUpperCase(c), mas para todos os símbolos como !@#$%^&*()_+ e vários sinais de pontuação não são considerados "maiúscula" embora eles exigem mudança para ser pressionado a fim de gerar thier keystroke. Eu tentei googling para ele, mas só encontrei um post no fórum com respostas satisfatórias. Existe alguma maneira para determinar se um personagem precisa mudar para ser pressionado e, em caso afirmativo, qual personagem é o "un-mudou" versão?

EDIT:. Aqui está o código que tenho até agora 

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);
    }
}
Foi útil?

Solução

Eu não sei uma maneira de resolver o seu problema diretamente (eu só acabou usando um mapa para os personagens), mas pode lhe dar algumas idéias: 

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();
        }
    }
}

Outras dicas

Eu não tenho certeza se o que você está procurando é possível. Você pode criar sua própria mesa, mas tenha em mente que ele vai, em seguida, trabalho para uma disposição do teclado só (muitas línguas têm os seus próprios layouts de teclado que são mais adequados para os seus conjuntos de caracteres específicos, também, há o layout Dvorak, que provavelmente tem a sua possuir mudou vs chaves não prefixadas) a menos que você levar em conta todos os layouts de teclado que você quer apoio, e criar tabelas personalizadas para aqueles.

Você pode usar classes AWT? Algo como este trabalho poder: 

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

if ((modifiers & KeyEvent.VK_SHIFT) == KeyEvent.VK_SHIFT) {
    // Shift pressed
}
Não afiliado a StackOverflow
scroll top