Titel | Inhalt | Suchen | Index | DOC | Handbuch der Java-Programmierung, 3. Auflage
<< | < | > | >> | API | Kapitel 32 - AWT-Dialogelemente

## 32.6 TextField

- 32.6 TextField

Ein `TextField` dient zur Darstellung und zur Eingabe von Text. Sowohl der Anwender als auch das Programm können den dargestellten Text auslesen und verändern.

    public TextField()

    public TextField(int width)

    public TextField(String text)

    public TextField(String text, int width)
| java.awt.TextField

Der parameterlose Konstruktor erzeugt ein leeres Textfeld, in das der Anwender beliebig viel Text eingeben kann. Wird mit `width` die Breite des Textfeldes vorgegeben, so beschränkt sich die Anzahl der auf dem Bildschirm angezeigten Zeichen auf den angegebenen Wert. Die Anzahl einzugebender Zeichen wird allerdings nicht begrenzt. Ist der Text länger, scrollt er innerhalb des Textfelds. Mit dem Parameter `text` kann eine Zeichenkette vorgegeben werden, die beim Aufruf des Textfeldes vorgelegt wird.

Die Klasse `Textfield` ist aus `TextComponent` abgeleitet. Sie besitzt eine ganze Reihe von Methoden, mit denen es möglich ist, auf den Text zuzugreifen oder die Eigenschaften des Textfeldes zu verändern. Die Methoden `getText` und `setText` werden zum Lesen und Verändern des Textes verwendet:

    public String getText()

    public void setText(String text)
| java.awt.TextField

Mit `getColumns` kann die Anzahl der darstellbaren Zeichen des Textfeldes abgefragt und mit `setColumns` verändert werden:

    public int getColumns()

    public void setColumns(int columns)
| java.awt.TextField

Zwei weitere Methoden stehen für das Markieren von Text zur Verfügung:

    public void selectAll()

    public void select(int first, int last)
| java.awt.TextField

`selectAll` markiert den kompletten Text und `select` den Bereich von `first` bis `last` (die Zählung beginnt bei 0). Mit den beiden Methoden `getSelectionStart` und `getSelectionEnd` kann die aktuelle Selektion abgefragt werden, `getSelectedText` liefert den selektierten Text:

    public int getSelectionStart()

    public int getSelectionEnd()

    public String getSelectedText()
| java.awt.TextField

Auf die aktuelle Cursorposition innerhalb des Textes kann mit den Methoden `getCaretPosition` und `setCaretPosition` zugegriffen werden:

    public int getCaretPosition()

    public void setCaretPosition(int position)
| java.awt.TextField

Des weiteren kann man verhindern, daß der Text geändert wird, und es besteht die Möglichkeit, verdeckte Eingaben (etwa für Paßwörter) zu realisieren:

    public void setEditable(boolean allowed)

    public boolean isEditable()

    public void setEchoCharacter(char c)

    public char getEchoChar()
| java.awt.TextField

Durch einen Aufruf von `setEditable` mit `false` als Parameter werden weitere Eingaben unterbunden. Der aktuelle Status kann mit `isEditable` abgefragt werden. Mit Hilfe von `setEchoCharacter` kann ein Zeichen übergeben werden, das bei jedem Tastendruck anstelle des vom Anwender eingegebenen Zeichens ausgegeben wird. Durch Übergabe eines '*' kann beispielsweise die verdeckte Eingabe eines Paßworts realisiert werden.

Ein Textfeld generiert ein Action-Event, wenn der Anwender innerhalb des Textfeldes die ENTER-Taste drückt. In diesem Fall liefert die Methode `getActionCommand` des Action-Events den Inhalt des Textfeldes. Eine Methode `setActionCommand`, die es wie bei Buttons erlaubt, den Rückgabewert von `getActionCommand` zu verändern, gibt es bei Textfeldern nicht. Um die Action-Events mehrerer Textfelder, die einen gemeinsamen Empfänger haben, unterscheiden zu können, kann mit `getSource` die Ereignisquelle abgefragt werden. Wird ein gemeinsamer Empfänger für alle Action-Events verwendet, so kann das von `getSource` gelieferte Objekt mit dem Operator `instanceof` daraufhin untersucht werden, ob es sich um ein `TextField` oder einen `Button` handelt. Für das nachfolgende Beispiel könnte das etwa so aussehen:

    001 /* TextField1.inc */
    002
    003 public void actionPerformed(ActionEvent event)
    004 {
    005   Object obj = event.getSource();
    006   if (obj instanceof TextField) {
    007     System.out.println(
    008       "ButtonAction: "+event.getActionCommand()
    009     );
    010   } else if (obj instanceof Button) {
    011     if (event.getActionCommand().equals("Ende")) {
    012       endDialog();
    013     }
    014   }
    015 }
| TextField1.inc

Listing 32.6: Verwendung von Textfeldern

Neben dem Action-Ereignis generiert ein Textfeld bei jeder Textänderung ein Text-Ereignis. Ein Empfänger für Text-Ereignisse kann mit der Methode `addTextListener` von `TextField` registriert werden, die als Argument ein Objekt erwartet, das das Interface `TextListener` implementiert. Beim Auftreten eines Text-Ereignisses wird im `TextListener` die Methode `textValueChanged` mit einem `TextEvent` als Parameter aufgerufen. `TextEvent` ist aus `AWTEvent` abgeleitet und erbt die Methoden `getID` und `getSource`, stellt darüber hinaus aber keine eigenen Methoden zur Verfügung. Typischerweise wird innerhalb von `textValueChanged` mit `getSource` das zugehörige `TextField` beschafft und mit `getText` auf seinen Inhalt zugegriffen:

    001 /* TextField2.inc */
    002
    003 public void textValueChanged(TextEvent event)
    004 {
    005   TextField tf = (TextField)event.getSource();
    006   System.out.println("textValueChanged: "+tf.getText());
    007 }
| TextField2.inc

Listing 32.7: Behandlung von Text-Events

Das folgende Beispiel zeigt die Anwendung von Textfeldern und die Registrierung von Empfängern für Text-Events und Action-Events. Das Beispiel demonstriert auch, wie man Textfelder und Beschriftungen kombinieren kann. Innerhalb des Dialogs werden in einem `FlowLayout` zwei Panels nebeneinander angeordnet. Das erste Panel enthält ein `GridLayout` mit drei Zeilen Beschriftung und das zweite ein `GridLayout` mit drei Textfeldern. Da die Höhe der Elemente im `GridLayout` in beiden Panels identisch ist, stehen Beschriftung und Text jeweils auf der gleichen Höhe nebeneinander.

    001 /* TextField3.inc */
    002
    003 private void customizeLayout(Panel panel)
    004 {
    005   panel.setLayout(new FlowLayout(FlowLayout.LEFT));
    006   Panel labelPanel = new Panel();
    007   labelPanel.setLayout(new GridLayout(3,1));
    008   labelPanel.add(new Label("Name",Label.LEFT));
    009   labelPanel.add(new Label("Vorname",Label.LEFT));
    010   labelPanel.add(new Label("Ort",Label.LEFT));
    011   Panel editPanel = new Panel();
    012   editPanel.setLayout(new GridLayout(3,1));
    013
    014   //Dieses Textfeld sendet Action- und Text-Ereignisse
    015   TextField tf = new TextField("Meier",20);
    016   tf.addActionListener(this);
    017   tf.addTextListener(this);
    018   editPanel.add(tf);
    019
    020   //Diese Textfelder senden keine Ereignisse
    021   editPanel.add(new TextField("Luise",20));
    022   editPanel.add(new TextField("Hamburg",20));
    023   panel.add(labelPanel);
    024   panel.add(editPanel);
    025 }
| TextField3.inc

Listing 32.8: Textfelder mit Beschriftung

Abbildung 32.6: Ein Dialog mit beschrifteten Textfeldern

Titel | Inhalt | Suchen | Index | DOC | Handbuch der Java-Programmierung, 3. Auflage, Addison Wesley, Version 3.0
<< | < | > | >> | API | © 1998-2002 Guido Krüger, http://www.javabuch.de