java - validar - Cómo puede un KeyListener detectar combinaciones de teclas(por ejemplo, ALT+1+1)

usar enter en java

Question

¿Cómo puedo dejar que mi KeyListener personalizado escuche las combinaciones de ALT (o CTRL ) + más que otra clave?

Supongamos que tengo 11 acciones diferentes que quiero que haga la aplicación, dependiendo de una combinación de teclas presionadas. ALT + 0 - ALT + 9 obviamente no plantea ningún problema, mientras que para ALT + 1 + 0 (o "ALT + 10", como podría describirse en un archivo de Ayuda o similar) no puedo encontrar una buena solución en ningún lugar del web (o en mi cabeza). No estoy convencido de que esta solución con temporizador sea ​​la única manera posible.

¡Un millón de gracias por adelantado por cualquier sugerencia!

Editar: Acciones 0-9 + acción 10 = 11 acciones. Gracias @ X-Zero.

Answer 1

ALT + 1 + 0 (o "ALT + 10" como se podría describir en un archivo de Ayuda o similar)

Parece chocar con (de uno de tus comentarios):

Entonces, por ejemplo, si el usuario desea cambiar los datos en la columna 11 (lo que se llamaría "10"), s / él presionará ALT + 1 + [deja de ALT y 1] 0.

Suponiendo que ALT + 10 significa "Presionar ALT, presionar y soltar 1, presionar y soltar 0, soltar ALT" Propongo intentar esto:

En KeyPressed, escuchando la tecla ALT, active una bandera booleana, isAltPressed y cree un búfer para mantener presionadas las teclas que se produzcan (una cadena, por ejemplo). En keyTyped, si isAltPressed está activo, agregue códigos de clave al búfer. En keyReleased, escuchando ALT nuevamente, abra un condicional consultando el búfer y ejecutando acciones.

    public void keyPressed (KeyEvent e){
        if (e.getKeyCode() == KeyEvent.VK_ALT){
        buffer = ""; //declared globally
        isAltPressed = true; } //declared globally
    }

    public void keyTyped (KeyEvent e){
        if (isAltPressed)
            buffer.append (e.getKeyChar());
    }

    public void keyReleased (KeyEvent e){
        if (e.getKeyCode() == KeyEvent.VK_ALT){
            isAltPressed = false;
            if (buffer.equals (4948)) //for pressing "1" and then "0"
                doAction();
            else if (buffer.equals(...))
                doOtherAction();
            ...
        }//if alt
    }

Answer 2

Creo que hay una forma más simple que estoy usando. Si el KeyEvent es ev entonces si investigas:

(int)ev.getKeyChar()

encuentra que ctrl - a es 1, ctrl - b es 2 y así sucesivamente. Quería usar ctrl - s para guardar. Así que solo uso:

(((int)ev.getKeyChar())==19)

para detectarlo. No tengo idea de por qué, pero funciona bien mientras que:

ev.isControlDown() && ev.getKeyChar()==''s''

no.

Answer 3

No debe utilizar KeyListener para este tipo de interacción. En su lugar, utilice enlaces de teclas, que puede leer en el Tutorial de Java . Luego puede usar la máscara InputEvent para representar cuando se presionan las distintas teclas modificadoras. Por ejemplo:

// Component that you want listening to your key
JComponent component = ...;
component.getInputMap().put(KeyStroke.getKeyStroke(KeyEvent.VK_SPACE,
                            java.awt.event.InputEvent.CTRL_DOWN_MASK),
                    "actionMapKey");
component.getActionMap().put("actionMapKey",
                     someAction);

Consulte el javadoc para KeyStroke para conocer los diferentes códigos que puede usar al obtener el KeyStroke. Estos modificadores se pueden OAR juntos para representar varias combinaciones de teclas. Como

KeyStroke.getKeyStroke(KeyEvent.VK_SPACE,
                       java.awt.event.InputEvent.CTRL_DOWN_MASK
                       | java.awt.event.InputEvent.SHIFT_DOWN_MASK)

Representar cuando se Ctrl + Shift las Ctrl + Shift .

Edit: Como se ha señalado, esto no responde a su pregunta, sino que debe tomarse como un buen consejo.

Answer 4

Puedes usar KeyListener para este propósito combinando ciertas cosas. Mire el siguiente ejemplo, que se debe colocar en un keyPressed(KeyEvent e) .

if (e.isControlDown() && e.getKeyChar() != ''a'' && e.getKeyCode() == 65) {
        System.out.println("Select All"); 
}

La cadena Select All se mostrará cuando se presione Ctrl + a . El método e.isControlDown() verifica si la tecla Ctrl está presionada o no. De manera similar, las combinaciones de teclas Alt se pueden hacer con el mismo método utilizando el método e.isAltDown() .

La lógica detrás de esto es que e.getKeyChar() devuelve el carácter de las pulsaciones de teclas y e.getKeyCode() devuelve su código ASCII. Cuando se presiona Ctrl y se mantiene presionada, la e.getKeyChar() no regresará y la e.getKeyCode() será la misma 65 . Espero que entiendas esto. Siéntete libre de pedir más.

Answer 5

Sugeriría que en lugar de usar combinaciones de teclas, considere algún campo de entrada cuando la ventana sea isVisible() y esté enfocada. El campo se puede ocultar, como la búsqueda de archivos ocultos en el Explorador de archivos de Windows (ingresar un directorio, escribir el nombre del archivo y la correspondencia está enfocada), o es visible, como en Ubuntu.

Las combinaciones de teclas no están diseñadas para incluir más de una tecla que no sean modificadores, aunque puede lograrlo.

Answer 6

import java.awt.*;
import java.awt.event.*;
class KDemo
{
     public static void main(String args[])
     {
           Frame f = new Frame();
           f.setSize(500,500);
           f.setVisible(true);
           f.addKeyListener(new KeyAdapter()
           {
               public void keyPressed(KeyEvent e)
               {
                   AWTKeyStroke ak = AWTKeyStroke.getAWTKeyStrokeForEvent(e);
                   if(ak.equals(AWTKeyStroke.getAWTKeyStroke(KeyEvent.VK_F4,InputEvent.ALT_MASK)))
                   {
                     System.exit(0);
                   }
               }
           });
        }
   }