Guido Krüger - JAVA 1.1 lernen - Kapitel 19

• Kapitel 19 - Low-Level-Events
  • Key-Events

Key-Events

Unter Windows werden alle Tastatureingaben an die fokussierte Komponente gesendet. Ein Empfänger für Key-Events muß das Interface KeyListener implementieren und bekommt Events des Typs KeyEvent übergeben. KeyEvent erweitert die Klasse InputEvent, die ihrerseits aus ComponentEvent abgeleitet ist, und stellt neben getID und getSource eine ganze Reihe von Methoden zur Verfügung, mit denen die Erkennung und Bearbeitung der Tastencodes vereinfacht wird.

Die Registrierung von Key-Events erfolgt mit der Methode addKeyListener, die auf allen Objekten des Typs Component oder daraus abgeleiteter Klassen zur Verfügung steht:

public void addKeyListener(KeyListener l);

Das Interface KeyListener definiert drei unterschiedliche Methoden:

public abstract void keyTyped(KeyEvent e);

public abstract void keyPressed(KeyEvent e);

public abstract void keyReleased(KeyEvent e)

Hinweis

Um die Funktionsweise dieser Methoden im Zusammenspiel mit den Methoden der Klasse KeyEvent besser verstehen zu können, wollen wir zwischen Zeichentasten und Funktionstasten unterscheiden. Zeichentasten sind dabei solche Tasten, mit denen Buchstaben, Ziffern oder sonstige gültige Unicode-Zeichen eingegeben werden, wie z.B. a, A, B, 1, 2, %, +, aber auch ESC, SPACE oder TAB. Zu den Funktionstasten gehören beispielsweise F1, F2, Pos1 oder CursorLinks, aber auch die Umschalttasten STRG, ALT und UMSCHALT.

Die Methode keyTyped wird immer dann aufgerufen, wenn eine Zeichentaste gedrückt wurde. Beim Drücken einer Funktionstaste wird sie dagegen nicht aufgerufen. Im Gegensatz dazu wird keyPressed bei jedem Tastendruck aufgerufen, unabhängig davon, ob es sich um eine Zeichentaste oder eine Funktionstaste handelt. Mit keyPressed können sogar in beschränktem Umfang die Feststelltasten wie NUM LOCK oder CAPS LOCK erkannt werden. Beide Methoden erhalten auch Tastatur-Repeats, werden also bei längerem Festhalten einer Taste wiederholt aufgerufen. Die Methode keyReleased wird aufgerufen, wenn eine gedrückte Taste losgelassen wurde, unabhängig davon, ob es sich um eine Zeichen- oder Funktionstaste handelte.

Um beim Auftreten eines Tastatur-Events zu erkennen, welche Taste gedrückt wurde, stellt die Klasse KeyEvent die Methoden getKeyCode und getKeyChar und zusätzlich die aus InputEvent geerbten Methoden isShiftDown, isControlDown, isMetaDown und isAltDown zur Verfügung:

public int getKeyCode();

public char getKeyChar();

public boolean isShiftDown();

public boolean isControlDown();

public boolean isMetaDown();

public boolean isAltDown();

getKeyChar liefert das Zeichen, das der gedrückten Zeichentaste entspricht, also ein "a", wenn die Taste A gedrückt wurde, und ein "A", wenn die Tastenkombination UMSCHALT+A gedrückt wurde. getKeyCode liefert dagegen virtuelle Tastencodes, die in KeyEvent als symbolische Konstanten definiert wurden. Hier wird beim Drücken der Taste A immer der Code VK_A geliefert, unabhängig davon, ob UMSCHALT gedrückt wurde oder nicht. Tabelle 19.4. gibt eine Übersicht der wichtigsten virtuellen Keycodes der Klasse KeyEvent.

Symbolischer Name	Bedeutung
VK_0 ... VK_9	0 ... 9
VK_A ... VK_Z	A ... Z
VK_ENTER	Enter
VK_SPACE	Leertaste
VK_TAB	Tabulator
VK_ESCAPE	Escape
VK_BACK_SPACE	Rückschritt
VK_F1 ... VK_F12	Die Funktionstasten F1 ... F12
VK_HOME, VK_END	Home, End
VK_INSERT, VK_DELETE	Einfg, Entf
VK_PAGE_UP, VK_PAGE_DOWN	BildHoch, BildRunter
VK_DOWN, VK_UP	CursorHoch, CursorRunter
VK_LEFT, VK_RIGHT	CursorLinks, CursorRechts

Tabelle 19.4: Virtuelle Key-Codes

Am einfachsten ist es, innerhalb von keyTyped mit getKeyChar die Zeichentasten abzufragen. Dabei liefert getKeyChar stets den ASCII-Code der gedrückten Zeichentaste zurück, Funktionstasten werden nicht übertragen. Der Rückgabewert von getKeyCode ist in diesem Fall immer KeyEvent.VK_UNDEFINED. Sollen dagegen auch Funktionstasten abgefragt werden, muß die Methode keyPressed bemüht werden. Hier ist etwas Vorsicht geboten, denn es wird auf alle Tastendrücke reagiert, und sowohl getKeyCode als auch getKeyChar liefern Werte zurück. Die Unterscheidung von Zeichen- und Funktionstasten kann in diesem Fall mit Hilfe von getKeyChar vorgenommen werden, deren Rückgabewert die Konstante KeyEvent.CHAR_UNDEFINED ist, wenn eine Funktionstaste gedrückt wurde.

Die is-Methoden sind bereits bekannt, mit ihnen können die Umschalttasten abgefragt werden. Dies ist beispielsweise sinnvoll, um bei einer Funktionstaste herauszubekommen, ob sie mit gedrückter Umschalttaste ausgelöst wurde oder nicht. Allerdings sind die Umschalttasten im Event-Modell des JDK 1.1 keine Tottasten, sondern liefern selbst ein Key-Event und lösen die Methode keyPressed aus.

Insgesamt ist das Handling von Tastatur-Events nicht ganz trivial und erfordert etwas Aufwand bei der Unterscheidung von Zeichen-, Funktions-, Umschalt- oder Feststelltasten. Tabelle 19.5 faßt die bisherigen Ausführungen noch einmal zusammen. Die erste Zeile zeigt das Verhalten beim Aufruf der Listener-Methode keyTyped, die zweite beim Aufruf von keyPressed an. Die erste Spalte liefert dazu den Rückgabewert von getKeyCode, die zweite den von getKeyChar. Jedes Element beschreibt in der oberen Hälfte den Rückgabewert beim Drücken einer Zeichentaste und in der unteren den beim Drücken einer Funktionstaste.

	getKeyCode	getKeyChar
keyTyped	Zeichentaste: VK_UNDEFINED Funktionstaste: --	Zeichentaste: Taste als char Funktionstaste: --
keyPressed	Zeichentaste: VK_... Funktionstaste: VK_...	Zeichentaste: Taste als char Funktionstaste: CHAR_UNDEFINED

Tabelle 19.5: Rückgabecodes bei Tastaturereignissen

Beispiel

Das folgende Beispiel demonstriert die Abfrage der Tastaturereignisse. Es implementiert keyPressed, um die Funktiontasten F1 bis F3 und den Status der Umschalttasten abzufragen. Jeder Tastendruck wird in einen String übersetzt, in msg1 gespeichert und durch Aufruf von repaint auf dem Bildschirm angezeigt. Nach dem Loslassen der Taste wird die Anzeige wieder vom Bildschirm entfernt. Weiterhin wurde keyTyped überlagert, um die Zeichentasten abzufragen. Jeder Tastendruck wird in msg2 gespeichert und ebenfalls auf dem Bildschirm angezeigt. Im Gegensatz zu den Funktionstasten bleibt die Ausgabe in diesem Fall erhalten, wenn die Taste losgelassen wird. Bei jedem weiteren Tastendruck wird sie um ein Zeichen ergänzt.

import java.awt.*;
import java.awt.event.*;

class WindowClosingAdapter
extends WindowAdapter
{
   public void windowClosing(WindowEvent event)
   {
      event.getWindow().setVisible(false);
      event.getWindow().dispose();
      System.exit(0);
   }
}

public class Example1906
extends Frame
implements KeyListener
{
   String msg1 = "";
   String msg2 = "";

   public static void main(String[] args)
   {
      Example1906 wnd = new Example1906();
   }

   public Example1906()
   {
      super("Example1906");
      addKeyListener(this);
      addWindowListener(new WindowClosingAdapter());
      setBackground(Color.lightGray);
      setSize(300,200);
      setLocation(200,100);
      setVisible(true);
   }

   public void paint(Graphics g)
   {
      if (msg1.length() > 0) {
         draw3DRect(g,20,50,250,30);
         g.setColor(Color.black);
         g.drawString(msg1,30,70);
      }
      if (msg2.length() > 0) {
         draw3DRect(g,20,100,250,30);
         g.setColor(Color.black);
         g.drawString(msg2,30,120);
      }
   }

   void draw3DRect(Graphics g, int x, int y, int width, int height)
   {
      g.setColor(Color.darkGray);
      g.drawLine(x,y,x,y+height);
      g.drawLine(x,y,x+width,y);
      g.setColor(Color.white);
      g.drawLine(x+width,y+height,x,y+height);
      g.drawLine(x+width,y+height,x+width,y);
   }

   public void keyPressed(KeyEvent event)
   {
      msg1 = "";
      if (event.getKeyChar() == KeyEvent.CHAR_UNDEFINED) {
         int key = event.getKeyCode();
         //Funktionstaste abfragen
         if (key == KeyEvent.VK_F1) {
            msg1 = "F1";
         } else if (key == KeyEvent.VK_F2) {
            msg1 = "F2";
         } else if (key == KeyEvent.VK_F3) {
            msg1 = "F3";
         }
         //Modifier abfragen
         if (msg1.length() > 0) {
            if (event.isAltDown()) {
               msg1 = "ALT + " + msg1;
            }
            if (event.isControlDown()) {
               msg1 = "STRG + " + msg1;
            }
            if (event.isShiftDown()) {
               msg1 = "UMSCHALT + " + msg1;
            }
         }
      }
      repaint();
   }

   public void keyReleased(KeyEvent event)
   {
      msg1 = "";
      repaint();
   }

   public void keyTyped(KeyEvent event)
   {
      char key = event.getKeyChar();
      if (key == KeyEvent.VK_BACK_SPACE) {
         if (msg2.length() > 0) {
            msg2 = msg2.substring(0,msg2.length() - 1);
         }
      } else if (key >= KeyEvent.VK_SPACE) {
         if (msg2.length() < 40) {
            msg2 += event.getKeyChar();
         }
      }
      repaint();
   }
}

Eine beispielhafte Ausgabe des Programms ist:

Abbildung 19.5: Darstellung von Tastaturereignissen