Tastaturereignisse für Menü- und Anwenderbereich

[kodela]

Hallo,

in meiner Sudoku-Anwendung kann mit den Cursor-Tasten der Fokus für eine selektierte Zelle verschoben werden.

Wenn ich nun mit F 10 die Menüzeile aktiviere, kann ich den Fokus für die selektierten Menüoptionen verschieben. Gleichzeitig wird aber auch im Sudokufeld der Fokus verschoben. Wie kann man das verhindern.

Ein weiteres Manko mit der Menü-Bedienung ist, dass das Menü auf der Enter-Taste nicht reagiert.

Das ist zwar alles nicht so besonders wichtig, denn wer bedient denn schon das Menü über die Tastatur. Trotzdem, es kann ja welche geben, die darauf angewiesen sind und da sollte das auch funktionieren.

Wie kann man also erreichen, dass Tastaturereignisse bei bei einem aktiven Menü ausschließlich vom Menü verarbeitet und nicht nach der Verarbeitung (oder ist es zuvor) einem anderen Programmteil zur Auswertung überlassen werden.

Konrad

 

[Marco13]

Mehr Infos. Wie ist es bisher? KeyListener, InputMap..? Ein bißchen Code schadet nie...

 

[kodela]

Hallo Marco13,

ich muss jetzt etwas ausholen und gestehen, dass ich offensichtlich fast zwei Jahre, seitdem ich meine ersten Java-Schritte gemacht habe, in einem Wespennest gesessen bin, ohne dass ich das bis jetzt eigentlich gemerkt habe. Es lief alles so gut und mein Sudoku-Programm, die Umsetzung einer sehr komplexen Excel-Anwendung zu einem eigenständigen Java-Programm, ist mir bis jetzt, wie ich meine, ganz gut gelungen.

Vieles wurde mir von der NetBeans-GUI abgenommen. Dazu zählt bedingt auch die Behandlung der Tastaturereignisse. Für alle Aktionen des Anwenders im eigentlichen Sudokufeld, einem swing.JPanel, musste ich allerdings selbst Hand anlegen. Dort muss es dem Anwender zum Beispiel möglich sein, jede der 81 Zellen zu selektieren, in leeren Zellen Eintragungen vorzunehmen oder aus solchen möglich erscheinende Zuweisungswerte (Kandidaten) auszuschließen und das alles sowohl per Maus und Tastatur. Dafür habe ich eigene Behandlungsmethoden für die Maus- und Tastaturereignisse geschrieben und mit folgendem Code eingebunden:

public class SudokuBoard extends javax.swing.JPanel {
    // Konstruktor
    public SudokuBoard(SudokuApp mFrame, Sudoku sdkKlasse) {
        ...

        addMouseListener(new MouseAdapter() {
            @Override
            public void mousePressed(MouseEvent evt) {
                myMousePressed(evt);
            }
        });

        addKeyListener(new KeyAdapter() {
            @Override
            public void keyPressed(KeyEvent evt) {
                myKeyPressed(evt);
            }
        });

        ...
        ...
        setFocusable(true);  // damit Key-Ereignisse übermittelt werden
    }

In myMousePressed() und myKeyPressed() werden dann alle Aktionen des Anwenders behandelt.

Wie bereits erwähnt, habe ich für das Hauptfenster mit der Menüleiste, einer Symbolleiste und zusätzlich einer Menge von Steuer-Buttons die Aktivierung der diversen Optionen per Maus bzw. auch Tastatur ausschließlich in der GUI-Umgebung von NetBeans festgelegt.

Bis auf die in meiner Anfrage erwähnte "Doppelauswertung" hat das bis jetzt auch (fast) immer geklappt. Von InputMaps habe ich bislang weder etwas gehört noch gelesen. Auf Deinen Hinweis hin habe ich natürlich sofort versucht, mich "schlau" zu machen, war damit bisher aber nicht besonders erfolgreich, was sicher auch darauf zurückzuführen ist, dass meine Englischkenntnisse mehr als bescheiden sind.

Ich weiß nicht, ob diese Informationen ausreichen, um mein Problem zu beurteilen, werde aber erforderlichenfalls auch auf weitere Details eingehen.

MfG, Konrad

 

[Marco13]

Ja, daran sieht man jetzt nicht so viel, was falsch sein könnte. Wenn ich das richtig verstanden habe läßt es sich ja runterkondensieren auf einen JFrame mit JMenu und einem JPanel, und an dem JPanel hängt ein MouseListener, der (der Beschreibung nach?!) AUCH dann noch Events bekommt, wenn eigentlich das JMenu aktiviert ist und man nur dort Einträge auswählen will?! Könnte man das in einem KSKB zusammenfassen?

 

[kodela]

Hallo Marco13,

bevor ich versuche, ein KSKB zu fabrizieren eine Klarstellung:

Es ist nicht die Maus, mit der ich Probleme habe, auf sie wurde nur der Vollständigkeit halber eingegangen, es ist die Tastatur. Wenn ich das Menü komplett über die Tastatur bedienen will, also Aktivierung des Menüs über F10, das ist ohne mein Zutun möglich, dann mit den Pfeiltasten innerhalb des Menüs den Fokus auf die gewünschte Option richten und diese mit Enter auswählen, dann funktioniert das erst einmal grundsätzlich bis auf zwei Dinge:

1.
Wenn man mit den Pfeiltasten sich im Menü bewegt, bewegt sich, den Pfeiltasten entsprechend, auch der Fokus im Sudokufeld.

2.
Man kann mit der Enter-Taste die im Menü fokusierte Option nicht auswählen.

Nach meinen Feststellungen wird jedes Tastaturereignis sofort an myKeyPressed() zur Auswertung übergeben und nur dann, wenn hier consume() nicht aufgerufen wird, erfolgt die Prüfung auf weitere Auswertungsmöglichkeiten.

Was die Enter-Taste anbelangt, wird diese nach meinen Feststellungen für die Menüauswahl überhaupt nicht ausgewertet, das durch sie zwar auch myKeyPressed() zuerst einmal aufgerufen wird, von dort erfolgt aber, wie auch für F10, sofort der Rücksprung. Trotzdem reagiert das Menü auf diese Taste nicht.

Ich habe auch versucht, auf die F10-Taste dem Menü explizit den Fokus zuzuweisen, um damit den Vorrang bei der Tastaturauswertung dem Menü zu geben, das ist mir aber bisher noch nicht gelungen.

MfG, Konrad

 

[vanny]

erstmal zu 2.

die MenuItems benötigen einen ActionListener, damit mit denen etwas passiert.


zu 1.

ich hätte jetzt nicht gedacht, dass sich dein JPanel so verhält, obwohl es ja dann scheinbar keinen Focus mehr besitzt.
Du kannst aber mit "hasFocus()" abfragen, ob dein JPanel aktiv ist und dem entsprechend auf die Tasten reagieren oder auch nicht.


Gruß Vanny

 

[Marco13]

Das hasFocus sollte nicht notwendig sein. Meine Kristallkugel sgat mir, dass du irgendwo in dem Code, den du NICHT gepostet hast,
frame.setMenuBar(b);
aufrufst, obwohl es
frame.setJMenuBar(b);
sein sollte (oder ähnliche Dinge, die mit Swing/AWT-Mischung zu tun haben)

 

[kodela]

Hallo zusammen,

damit man besser sehen kann, um was es mir geht, habe ich die entscheidenden Teile aus meinem Programm von (fast) allem Code, der für das Problem unwichtig ist, befreit.

Hier das Ergebnis, als erstes die Fenster-Klasse:

package menutest;

import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JPopupMenu;
import javax.swing.JRadioButtonMenuItem;


public class MenuTest extends JFrame {  
    
    public MenuTest() {
        super ("Anwendung zum Testen von Menüs");      
        initKomponenten();
        sdkBoard = new SdkBoard();
        add(sudokuFeld, BorderLayout.CENTER);       
        sudokuFeld.setOpaque(false); 
        sudokuFeld.add(sdkBoard);
        sdkBoard.requestFocusInWindow();
        pack();
        sdkBoard.repaint();
    }
    
    private void initKomponenten() {  
        sudokuFeld = new JPanel();  
        setLayout(new BorderLayout(10, 10));
        menuZeile = new javax.swing.JMenuBar(); 
        menuZeile.setPreferredSize(new Dimension(400, 28));        
        menuDatei = new JMenu("Datei");        
        menuDateiSdkEingeben = new JMenuItem("Neues Sudoku eingeben");
        menuDatei.add(menuDateiSdkEingeben);
        menuDateiSdkErstellen = new JMenuItem("Neues Sudoku erzeugen");
        menuDatei.add(menuDateiSdkErstellen);        
        jSeparator1 = new JPopupMenu.Separator();
        menuDatei.add(jSeparator1);        
        menuDateiLaden = new JMenuItem("Sudoku laden");
        menuDatei.add(menuDateiLaden);        
        menuDateiSpeichern = new JMenuItem("Sudoku speichern");
        menuDatei.add(menuDateiSpeichern);        
        jSeparator2 = new JPopupMenu.Separator();
        menuDatei.add(jSeparator2);        
        menueDateiBeenden = new JMenuItem("Beenden");
        menueDateiBeenden.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent evt) {
                menueDateiBeendenActionPerformed(evt);
            }
        });
        menuDatei.add(menueDateiBeenden);
        menuZeile.add(menuDatei);        
        menuLevel = new javax.swing.JMenu("Level");        
        menuLevel_1 = new JRadioButtonMenuItem("Level 1 - Moderat");
        menuLevel.add(menuLevel_1);        
        menuLevel_2 = new JRadioButtonMenuItem("Level 2 - Kniffelig");
        menuLevel.add(menuLevel_2);        
        menuLevel_3 = new JRadioButtonMenuItem("Level 3 - Tückisch");
        menuLevel.add(menuLevel_3);        
        menuLevel_4 = new JRadioButtonMenuItem("Level 4 - Happig");
        menuLevel.add(menuLevel_4);        
        menuLevel_5 = new JRadioButtonMenuItem("Level 5 - Teuflisch");
        menuLevel.add(menuLevel_5);        
        menuLevel_6 = new JRadioButtonMenuItem("Level 6 - Extrem");
        menuLevel.add(menuLevel_6);        
        menuZeile.add(menuLevel);
        menuInfo = new JMenu("Hilfe");        
        menuInfoProgramm = new JMenuItem("Hinweise zum Programm");
        menuInfo.add(menuInfoProgramm);        
        menuInfoLoesungstechniken = new JMenuItem("Lösungstechniken");
        menuInfo.add(menuInfoLoesungstechniken);        
        jSeparator3 = new JPopupMenu.Separator();
        menuInfo.add(jSeparator3);        
        menuInfoUeber = new JMenuItem("Über ...");
        menuInfo.add(menuInfoUeber);       
        menuZeile.add(menuInfo);        
        setJMenuBar(menuZeile);        
    }

    private void menueDateiBeendenActionPerformed(ActionEvent evt) {                                                  
        System.exit(0);
    }                                                 
    
    public static void main(String[] args) {
        EventQueue.invokeLater(new Runnable() {
            @Override
            public void run() {
                new MenuTest().setVisible(true);
            }
        });
    }

    private JMenuBar menuZeile;
    private JMenu menuDatei;
    private JMenuItem menuDateiSdkEingeben;
    private JMenuItem menuDateiSdkErstellen;
    private JMenuItem menuDateiLaden;
    private JMenuItem menuDateiSpeichern;
    private JMenuItem menueDateiBeenden;        
    private JMenu menuLevel;
    private JRadioButtonMenuItem menuLevel_1;
    private JRadioButtonMenuItem menuLevel_2;
    private JRadioButtonMenuItem menuLevel_3;
    private JRadioButtonMenuItem menuLevel_4;
    private JRadioButtonMenuItem menuLevel_5;
    private JRadioButtonMenuItem menuLevel_6;        
    private JMenu menuInfo;
    private JMenuItem menuInfoProgramm;
    private JMenuItem menuInfoLoesungstechniken;
    private JMenuItem menuInfoUeber;
    private JPopupMenu.Separator jSeparator1;
    private JPopupMenu.Separator jSeparator2;
    private JPopupMenu.Separator jSeparator3;
    private JPanel sudokuFeld;
    private SdkBoard sdkBoard;
}

und hier noch die Klasse für das Sudokufeld:

package menutest;

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;


public class SdkBoard extends javax.swing.JPanel {
    
    public SdkBoard() {
        setPreferredSize(new Dimension(469, 469));
        addKeyListener(new KeyAdapter() {
            @Override
            public void keyPressed(KeyEvent evt) {
                myKeyPressed(evt);
            }
        });
        setSize(new Dimension(BOARDSIZE, BOARDSIZE));
        setBackground(Color.WHITE);
        setFocusable(true);
        select = 40;
    }
    
    @Override
    public void paintComponent(Graphics g) {
        ausgebenBoard(g);
        ausgebenWerte(g);
        requestFocusInWindow();
    }

     private void ausgebenBoard(Graphics g) {
        // Umfassung ausgeben
        g.setColor(Color.BLACK);
        g.fillRect(0, 0, BOARDSIZE, BOARDSIZE);
        g.setColor(new Color(0, 128, 0));
        g.fillRect(ALINIE, ALINIE,
                BOARDSIZE - 2 * ALINIE, BOARDSIZE - 2 * ALINIE);
        // Sudoku-Feld ausgeben
        g.setColor(Color.BLACK);
        g.fillRect(RAND - ALINIE, RAND - ALINIE,
                FELDSIZE + 2 * ALINIE, FELDSIZE + 2 * ALINIE);
        g.setColor(new Color(230, 245, 230));
        g.fillRect(RAND, RAND, FELDSIZE, FELDSIZE);
        g.setColor(Color.BLACK);
        g.fillRect(RAND, ZELLPOSRU[2] + RAND, BOARDSIZE - 2 * RAND, BLINIE);
        g.fillRect(RAND, ZELLPOSRU[5] + RAND, BOARDSIZE - 2 * RAND, BLINIE);
        g.fillRect(ZELLPOSRU[2] + RAND, RAND, BLINIE, BOARDSIZE - 2 * RAND);
        g.fillRect(ZELLPOSRU[5] + RAND, RAND, BLINIE, BOARDSIZE - 2 * RAND);

        for (int i = 0; i < BEREICHE; i++) {                                
            int basisPos = ZELLPOSRU[i] + RAND;
            if ((i + 1) % BREIHEN != 0) {
                g.drawLine(basisPos, RAND, basisPos, BOARDSIZE - RAND - 1);
                g.drawLine(RAND, basisPos, BOARDSIZE - RAND - 1, basisPos);
            }
        }
    }   
 
    private void ausgebenWerte(Graphics g) {
            int z = select / 9;
            int s = select % 9;
                g.setColor(Color.DARK_GRAY);
                g.drawRect(ZELLPOSLO[s] + RAND + 1,
                        ZELLPOSLO[z] + RAND + 1,
                        ZELLSIZE - 3, ZELLSIZE - 3);
    }

    private void myKeyPressed(java.awt.event.KeyEvent evt) {
        if (evt.getKeyCode() == KeyEvent.VK_F10) {
            return;
        }
        int code = evt.getKeyCode();
        if (evt.isActionKey() && (code >= KeyEvent.VK_LEFT && code <= KeyEvent.VK_DOWN)) {
            auswertenNavigation(code);
            repaint();
//            evt.consume();
            return;
        }
        repaint();
    }
    
    private void auswertenNavigation(int taste) {
        switch (taste) {
            case KeyEvent.VK_UP:
                select -= 9;
                if (select < 0) {
                    select = 81 + select;
                }
                break;
            case KeyEvent.VK_DOWN:
                select += 9;
                if (select > 80) {
                    select = select - 81;
                }
                break;
            case KeyEvent.VK_LEFT:
                select--;
                if (select < 0) {
                    select = 80;
                }
                break;
            case KeyEvent.VK_RIGHT:
                select++;
                if (select > 80) {
                    select = 0;
                }
        }
    }    
    
    private int select;
    private static final int ALINIE = 3;
    private static final int RAND = 21 + 2 * ALINIE;
    private static final int ZELLSIZE = 45; 
    private static final int BLINIE = 2;
    private static final int ZLINIE = 1;
    private static final int BEREICHE = 9;
    private static final int BREIHEN = 3;
    private static final int FELDSIZE = ZELLSIZE * BEREICHE + 2 * BLINIE + 6 * ZLINIE;
    private static final int BOARDSIZE = FELDSIZE + 2 * RAND;
    // erste Position einer Zelle links und oben
    private static final int[] ZELLPOSLO = {0, 46, 92, 139, 185, 231, 278, 324, 370};
    // letzte Position einer Zelle rechts und unten
    private static final int[] ZELLPOSRU = {45, 91, 137, 184, 230, 276, 323, 369, 415};
}

Es gibt im Verhalten dieses Beispiel-Codes zu meinem Programm allerdings einen Unterschied. Wenn man hier nach der F10-Taste mit der Pfeil-Ab-Taste in das Datei-Menü geht, dann funktioniert alles so wie es sein sollte. Man kann sich mit den Pfeiltasten durch das Datei-Menü bewegen und kann mit der Enter-Taste auch erfolgreich die Beenden-Option (die einzige "lebende" Option in diesem Menü) auswählen.

Wenn man jedoch das Dateimenü verlässt, sieht man sofort, dass sich im Sudokufeld nun auch der Fokus für die selektierte Zelle ändert. Den Fokus hat die Zelle, in der zusätzlich ein feines Qudarat gezeichnet ist. Beim Start des Programmes ist dies die Zelle im Zentrum.

Nun lässt sich auch im Datei-Menü die Beenden-Option nicht mehr aktivieren.

Im Gegensatz zu dieser Test-Version wird in meinem Programm nach Aktivierung des Menüs über F10 von Anfang an die Methode myKeyPressed() aufgerufen. Damit wird sowohl im Menü wie auch im Sudokufeld über die Pfeiltasten der Fokus verschoben. Die Auswahl über die Enter-Taste ist zu keinem Zeitpunkt möglich.

Es wäre auch sehr interessant, den Grund für diesen Unterschied herauszufinden.

MfG, Konrad

 

[kodela]

Hallo,

eben habe ich festgestellt, dass die Ursache für dieses eigentümliche Verhalten der Aufruf von requestFocusInWindow() in paintComponent() ist (Zeile 31 von SdkBoard).

Wenn ich in meinem Programm diesen Aufruf allerdings weglasse, reagiert die SdkBoard-Klasse nicht mehr auf Tastaturereignisse, wenn ich im Hauptfenster irgend etwas mache, also zum Beispiel über einen Button einen Filter wechsle. Dies ist natürlich in dem Beispielprogramm nicht integriert.

Aber auch das habe ich in den Griff bekommen. Jetzt wird eben zum Abschluss jeder Aktivität im Hauptfenster (zum Beispiel Filter setzten) für SdkBoard requestFocusInWindow() aufgerufen.

MfG, Konrad

 

[Sunchezz]

Spontan fällt mir ein nen neuen EventQueue zu pushen, damit sollten die Pfeiltasten programmweit reagieren.
In deinem Code musste dann nur noch unterscheiden ob die EventSource nen Menü ist.

 

[bERt0r]

Warum braucht denn dein Sudokufeld überhaupt einen Fokus zugewiesen? Wenn der Benutzer den Fokus draufhaben will, dann kann er ja reinklicken. Erklär mal was du dir vorstellst, was request Focus machen soll.

 

[Marco13]

Wenn ich's richtig verstanden habe, ist das jetzt erledigt?

Das Problem war wohl, dass man den "Cursor" im Feld bewegen konnte, aber wenn man danach z.B. auf einen Button außerhalb des Feldes geklickt hatte, der Focus erstmal DORT war - und man nicht mehr den Cursor im Fehld bewegen konnte (außer, wenn man vorher nochmal reingeklickt hat). Das requestFocusInWindow soll jetzt wohl erreichen, dass man IMMER mit den Pfeiltasten den Cursor bewegen kann, egal wo der Focus (kurzzeitig) sonst hingewandert ist.

Eleganter wäre das vermutlich mit den schon angesprochenen Input/ActionMaps und Key Bindings...

 

[kodela]

Hallo,

bERtOr schreibt:

Warum braucht denn dein Sudokufeld überhaupt einen Fokus zugewiesen? Wenn der Benutzer den Fokus draufhaben will, dann kann er ja reinklicken.

Das Sudokufeld, genauer eine Zelle davon, braucht den Fokus, damit ein Anwender, der aus welchen Gründen auch immer mit der Maus nicht reinklicken kann oder will, den Inhalt der selektierten Zelle ändern kann, also entweder einen Wert zuweisen oder einen bisher noch möglich erscheinenden Zuweisungswert (Kandidat) auszuschließen.

Die Bedienung soll sowohl ausschließlich über die Tastatur, aber natürlich auch über die Maus möglich sein.

Marco13 schreibt:

Eleganter wäre das vermutlich mit den schon angesprochenen Input/ActionMaps und Key Bindings...

Da magst Du Recht haben, nur blicke ich da im Augenblick noch nicht durch, aber ich habe mir Deinen Hinweis für eine spätere Überarbeitung auf jeden Fall einmal vorgemerkt.

Für mich ist das Problem im Augenblick gelöst und ich danke allen, die sich bemüht haben, mir die Augen ein wenig zu öffnen.

MfG, Konrad

 

[Sunchezz]

Also is das Problem jetzt abgehakt?

 

[kodela]

Ja, es ist abgehakt.

Mein Fehler war, dass ich mit dem Aufruf von requestFocusInWindow() ja den Focus geradezu von allen anderen Komponenten, also auch dem Menü, abgezogen habe.

Das hat ganz gut funktioniert, bis ich dann geprüft habe, ob die Menübedienung per Tastatur auch einwandfrei funktioniert und feststellen musste, dass dem nicht so war.

Jetzt ist das requestFocusInWindow() in der Klasse für das Sudokufeld entfernt und ich sorge in der Klasse des Hauptfensters dafür, dass das Sudokufeld auch immer dann, wenn es sinnvoll ist, den Fokus bekommt.

Nochmals vielen Dank an alle, die sich mit meinem Problem beschäftigt haben.

MfG, Konrad