Der Fokus zeigt an, welches Fenster die Tastatureingaben erhält.
Sind mehrere Fenster gleichzeitig geöffnet, so kann immer nur
eines von ihnen den Fokus beanspruchen. Sind auf einem aktiven Fenster
mehrere Dialogelemente aktiv, so kann ebenfalls nur eines davon den
Fokus erhalten, denn jedes Dialogelement wird ebenfalls durch ein
(meist unsichtbares) Fenster dargestellt.
Ein Empfänger für Focus-Events muß das Interface FocusListener
implementieren und bekommt Events des Typs FocusEvent
übergeben. FocusEvent
erweitert die Klasse ComponentEvent
und stellt neben getID
und getSource
die Methode isTemporary
zur Verfügung, die anzeigt, ob der Fokuswechsel temporär
oder permanent ist:
Die Registrierung von Focus-Events erfolgt mit der Methode addFocusListener,
die auf allen Objekten des Typs Component
oder daraus abgeleiteten Objekten zur Verfügung steht:
Das Interface FocusListener
enthält lediglich zwei unterschiedliche Methoden:
focusGained
wird aufgerufen, wenn die Komponente den Fokus erhält, und focusLost,
wenn sie ihn wieder abgibt. Eine Komponente erhält den Fokus
beispielsweise, wenn sie mit der Maus angeklickt oder (unter Windows)
mit Hilfe der Tasten [TAB] oder
[UMSCHALT]+[TAB]
oder über einen Beschleuniger angesprungen wurde. Außerdem
gibt es die Möglichkeit, den Fokus programmgesteuert zu verändern.
Dazu gibt es die Methode requestFocus
der Klasse Component,
mit der eine Komponente den Fokus für sich selbst beanspruchen
bzw. ihn einer anderen Komponente zuweisen kann:
|
Der explizite Umgang mit Focus-Events ist etwa bei Dialogelementen
sinnvoll. Dadurch kann ein Edit-Control beispielsweise feststellen,
daß das nächste Dialogelement angesprungen werden soll
und ein eventuell geänderter Text zuvor gespeichert werden muß.
Focus-Events sind oft schwierig zu debuggen, denn durch den Wechsel
zwischen Debug-Window und Anwendung werden meist zusätzliche
Fokuswechsel ausgelöst, die den Fehler verschleiern oder die
Fehlerstelle unerreichbar machen. Wird innerhalb von Fokus-Handlern
die Methode requestFocus
aufgerufen, kann es zudem leicht zu Endlosschleifen kommen. |
 |
|
|
|
Das folgende Programm zeigt die Anwendung eines FocusListener-Interfaces
zur Implementierung der Methoden focusGained
und focusLost
auf einem Frame-Objekt.
Wenn das Fenster den Eingabefokus erhält, wird der Hintergrund
gelb und gibt die Meldung »Fokus erhalten« aus. Verliert
das Fenster den Fokus, so wird der Hintergrund grau und die Meldung
»Kein Fokus« wird angezeigt. Die Registrierung des Fokusempfänger-Objekts
erfolgt durch Aufruf von addFocusListener(this),
bei dem das Fensterobjekt sich selbst als Empfänger registriert:
001 /* Listing1905.java */
002
003 import java.awt.*;
004 import java.awt.event.*;
005
006 class WindowClosingAdapter1905
007 extends WindowAdapter
008 {
009 public void windowClosing(WindowEvent event)
010 {
011 event.getWindow().setVisible(false);
012 event.getWindow().dispose();
013 System.exit(0);
014 }
015 }
016
017 public class Listing1905
018 extends Frame
019 implements FocusListener
020 {
021 boolean havefocus = false;
022
023 public static void main(String[] args)
024 {
025 Listing1905 wnd = new Listing1905();
026 }
027
028 public Listing1905()
029 {
030 super("Listing1905");
031 addFocusListener(this);
032 addWindowListener(new WindowClosingAdapter1905());
033 setBackground(Color.lightGray);
034 setSize(300,200);
035 setLocation(200,100);
036 setVisible(true);
037 }
038
039 public void paint(Graphics g)
040 {
041 if (havefocus) {
042 g.setColor(Color.black);
043 g.drawString("Fokus erhalten",10,50);
044 } else {
045 g.setColor(Color.darkGray);
046 g.drawString("Kein Fokus",10,50);
047 }
048 }
049
050 public void focusGained(FocusEvent event)
051 {
052 havefocus = true;
053 setBackground(Color.yellow);
054 repaint();
055 }
056
057 public void focusLost(FocusEvent event)
058 {
059 havefocus = false;
060 setBackground(Color.lightGray);
061 repaint();
062 }
063 }
|
Listing1905.java |
Listing 19.5: Behandlung von Fokus-Ereignissen
|
|
|
|
|
Das Programm verwendet zwei unterschiedliche Techniken, um Ereignisempfänger
zu registrieren. Für die Focus-Events implementiert es das FocusListener-Interface
und registriert sich bei sich selbst. Dies ist eine vernünftige
Vorgehensweise, da sämtliche Methoden des Interfaces benötigt
werden. Das windowClosing-Event
wird dagegen von der externen Klasse WindowClosingAdapter1905
zur Verfügung gestellt, die sich aus WindowAdapter
ableitet und die Methode windowClosing
mit der Funktionalität zum Schließen des Fensters und zum
Beenden des Programms belegt. Diese Technik demonstriert beispielhaft
die Entwicklung spezialisierter Adapterklassen, die mehrfach verwendet
werden können. |
|
|
|
Die Ausgabe des Programms (nachdem es den Fokus erhalten hat) ist:
Abbildung 19.4: Programm nach Erhalt des Eingabefokus