web-dev-qa-db-fra.com

Comment un KeyListener peut-il détecter des combinaisons de touches (par exemple, ALT + 1 + 1)

Comment puis-je laisser ma coutume KeyListener écouter les combinaisons de ALT (ou CTRL d'ailleurs) + de plus d'une autre touche?

Supposons que j'ai 11 actions différentes que je souhaite que l'application effectue, en fonction d'une combinaison de touches appuyée. ALT + 0 - ALT + 9 ne pose évidemment aucun problème, alors que pour ALT + 1 + 0 (ou "ALT + 10", comme cela pourrait être décrit dans un fichier d'aide ou similaire), je ne trouve pas de bonne solution où que ce soit sur le Web (ou dans ma tête). Je ne suis pas convaincu que cette solution avec une minuterie est le seul moyen possible.

Merci mille fois d'avance pour vos suggestions!

Edit: Actions 0-9 + action 10 = 11 actions. Merci @ X-Zero.

javaswingcombinationskeylistenerkeyevent
19
s.d

Vous ne devez pas utiliser KeyListener pour ce type d'interaction. À la place, utilisez des raccourcis clavier, que vous pouvez lire dans le Tutoriel Java . Ensuite, vous pouvez utiliser le masque InputEvent pour indiquer quand les différentes touches de modification sont supprimées. Par exemple:

// 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);

Consultez le javadoc pour KeyStroke pour connaître les différents codes que vous pouvez utiliser lors de l'obtention du KeyStroke. Ces modificateurs peuvent être combinés pour représenter diverses combinaisons de touches. Tel que

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

Pour représenter quand les touches Ctrl + Shift ont été enfoncées.

Edit: Comme il a été souligné, cela ne répond pas à votre question, mais devrait plutôt être considéré comme un bon conseil.

26
Jonathan Spooner

Vous pouvez utiliser KeyListener à cette fin en combinant certaines choses. Regardez l'exemple suivant, qui devrait être placé dans une méthode keyPressed(KeyEvent e) surchargée.

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

La chaîne Select All sera affichée lorsque Ctrl + a est pressé. La méthode e.isControlDown() vérifie si le Ctrl la touche est enfoncée ou non. De même, le Alt les combinaisons de touches peuvent être effectuées avec la même méthode en utilisant la méthode e.isAltDown().

La logique derrière ceci est, e.getKeyChar() renvoie le caractère de la touche enfoncée et e.getKeyCode() renvoie son code ASCII. Quand Ctrl est enfoncée, la e.getKeyChar() ne retournera pas a et e.getKeyCode() sera le même 65. J'espère que vous comprenez cela. N'hésitez pas à demander plus.

19
Sasivarnan

ALT + 1 + 0 (ou "ALT + 10" comme cela pourrait être décrit dans un fichier d'aide ou similaire)

semble entrer en conflit avec (de l'un de vos commentaires):

Ainsi, par exemple, si l'utilisateur souhaite modifier les données de la colonne 11 (appelée "10"), il doit appuyer sur ALT + 1 + [permet de passer de ALT à 1] 0.

En supposant que ALT + 10 signifie 'appuyer sur ALT, appuyer et relâcher 1, appuyer sur 0, relâcher ALT', je propose d'essayer ceci:

Dans keyPressed, écoutez la touche ALT, activez un indicateur booléen, isAltPressed, et créez un tampon pour conserver les appuis sur les touches qui se produisent (une chaîne, par exemple). Dans keyTyped, si isAltPressed est actif, ajoutez des codes de clé au tampon . Dans keyReleased, réécoutez ALT, ouvrez une requête conditionnelle interrogeant le tampon et exécutant des actions.

    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
    }
2
sideways8

Je pense qu'il y a un moyen plus simple que j'utilise. Si le KeyEvent est ev alors si vous étudiez:

(int)ev.getKeyChar()

vous trouvez ça ctrl-a est 1, ctrl-b est 2 et ainsi de suite. Je voulais utiliser ctrl-s pour sauver. Donc je viens d'utiliser:

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

pour le détecter. Je ne sais pas pourquoi, mais ça fonctionne bien alors que:

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

ne fait pas.

0
dave110022

Je suggérerais qu'au lieu d'utiliser des combinaisons de touches, considérons un champ de saisie lorsque la fenêtre isVisible() et est focalisée. Le champ peut être masqué, comme la recherche de nom de fichier caché dans l'Explorateur de fichiers de Windows (entrez un répertoire, tapez le nom du fichier et la correspondance est sélectionnée), ou est visible, comme dans Ubuntu. 

Les combinaisons de touches ne sont pas conçues pour inclure plus d'une touche autre que des modificateurs, bien que vous puissiez peut-être y parvenir.

0
WesternGun
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);
                   }
               }
           });
        }
   }
0
Venkat Esan