In Ihrem Leben als Java-EntwicklerIn ist es wohl eher unwahrscheinlich, dass Sie eine komplette Textverarbeitung in Java programmieren werden. Dennoch können Sie mit dem punktuellen Einsatz von Formatierungen und Textauszeichnungen Ihre Anwendungen optisch aufwerten und ergonomischer gestalten. Beispiel Hilfetexte: Selbst wenn Sie nicht die JavaHelp-Technologie einsetzen, können Sie erläuternde Dokumentation zu Ihren Anwendungen in HTML verfassen und durch Swing-Komponenten anzeigen lassen. Beispiel Annotationen: Ein Benutzer mag zu einzelnen Datensätzen eines Geschäftsvorgangs eigene Bemerkungen hinzufügen. Hierbei könnte es ihm erlaubt sein, einzelne Wörter fett oder kursiv hervorzuheben. Beispiel Konsole: Eine Anwendung, die eine länger dauernde Aktion in einem separatem Thread oder System-Prozess startet, mag die verschiedenen Ausgaben dieser Aktion in einer Konsole anzeigen. Warnungen oder Fehler (oder Ausgaben nach System.err anstatt System.out) könnten sogleich durch eine rote Schrift automatisch kenntlich gemacht werden. Beispiel Syntax Highlighting: Ein Editor für eine proprietäre Skript- oder Makrosprache könnte Schlüsselwörter und Kommentare farblich hervorheben. Für diese verschiedenen Anwendungsfälle bietet Ihnen das Swing-API jeweils unterschiedlich geeignete Mittel und Wege:

• Mit der JEditorPane können Sie Texte im HTML- oder RTF-Format anzeigen lassen.
• Mit AttributeSets können Sie programmatisch Textattribute ändern und neue Abschnitte mit speziell definierten Formatierungen einfügen.
• Mit Styles können Sie benannte AttributeSets komfortabler verwenden.
• Mit EditorKits bekommen Sie Actions zur Textmanipulation, die Sie direkt an Oberflächenkomponenten wie JMenuItems oder JButtons anbinden können.

Im folgenden werden wir diese vier Mechanismen betrachten und in Beispielen angewandt finden.

JEditorPane

JEditorPane bietet sich an, wenn Sie komplette Texte im HTML- oder RTF-Format darstellen wollen. Diese können schon statisch vorliegen, wie etwa Hilfetexte, Sie können sie aber auch dynamisch zur Laufzeit des Programms zusammenbauen, wie etwa Berichte über einen Datenbestand (Abb. 1). Die Verwendung der JEditorPane ist schnell programmiert. Zum Darstellen von dynamisch zusammengebautem Text erzeugen Sie eine Instanz, sagen ihr den Mime-Type des Inhalts (text/html oder text/rtf) und übergeben ihr dann den Text als String. Wie üblich bei datenanzeigenden Swing-Komponenten mit eventuell umfangreichem Inhalt bauen Sie die JEditorPane in eine JScrollPane ein. (Wussten Sie, dass ab dem JDK1.4 zum Scrollen die Mouse-Wheels unterstützt werden?).

Listing 1

1. import java.awt.*;
2. import java.text.*;
3. import java.util.*;
4. import javax.swing.*;
6. class HtmlStringAnzeiger extends JPanel {
8. public static void main(String args[]) throws Exception {
9. JFrame f = new JFrame("HtmlStringAnzeiger");
11. // Hier wird der anzuzeigende Text dynamisch zur
12. // Laufzeit zusammengestellt.
13. DateFormat dateFormat =
14. DateFormat.getDateInstance(DateFormat.LONG);
15. int wert = 3;
16. String text =
17. "<h1>Inventar</h1><p>Am "
18. +dateFormat.format(new Date())
19. +" besitzen Sie </p><ul><li>"
20. +wert
21. +" Exemplare der besonders seltenen marelukkischen</li></ul>";
23. f.getContentPane().add(new HtmlStringAnzeiger(text), BorderLayout.CENTER);
24. f.setBounds(10,10,225,180);
25. f.setVisible(true);
26. f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
27. }
29. // Hier wird einer JEditorPane der Mime-Type und der Text
30. // zugewiesen und diese dann in eine JScrollPane gepackt
31. HtmlStringAnzeiger(String text) throws Exception {
32. setLayout(new BorderLayout());
34. JEditorPane pane = new JEditorPane();
35. pane.setContentType("text/html");
36. pane.setText(text);
37. pane.setEditable(false);
39. JScrollPane scrollPane = new JScrollPane(pane);
40. add(scrollPane, BorderLayout.CENTER);
41. }

Das nachträgliche programmatische Ändern von angezeigtem Text, etwa mit einer append()-Methode, ist in der JEditorPane nicht vorgesehen. Man kommt also eventuell auf die Idee, für Änderungen den kompletten Text zu ersetzen - was für viele kleine Änderungen unvernünftig ist. Sie können sich allerdings von der JEditorPane auch das darunter liegende Dokument geben lassen, dieses ist das Model der JEditorPane und enthält die anzuzeigenden Daten (eine ähnliche Arbeitsteilung wie bei einer JList und ihrem ListModel). Falls der Inhaltstyp eben text/html ist, handelt es sich bei diesem Dokument um ein HTMLDocument aus dem Package javax.swing.text.html. Es enthält Methoden wie:

1. public void insertBeforeStart(<br></br> Element elem,
2. String htmlText)
3. oder
5. public void insertAfterEnd(
6. Element elem,
7. String htmlText)

mit denen Sie ganze HTML-Elemente einfügen können. Zusätzlich zum Text müssen Sie allerdings das Elternelement angeben, letztlich müssten Sie also die komplette Element-Struktur des HTMLDocuments kennen und benutzen. Der Artikel TicTacToe Revisited [1] der Java Swing Connection beschreibt eine mögliche Vorgehensweise. Für unsere einfachen Beispielanwendungen wäre diese Vorgehensweise unangemessener Aufwand, wir werden ja noch andere Möglichkeiten kennen lernen, mit Dokumenten sinnvoll zu arbeiten.

Für den anderen Fall der Darstellung von bereits vorhandenen HTML-Dateien übergeben Sie der Instanz der JEditorPane eine URL, die auf eine solche HTML-Datei zeigt. Da Hilfetexte meist mit Querverweisen ausgestattet sind (oder zumindest sein sollten) müssen Sie die JEditorPane noch dazu bringen, beim Klicken auf einen Hyperlink diesen Querverweisen auch zu folgen. Dazu brauchen Sie einen HyperlinkListener, der auf HyperlinkEvents der JEditorPane reagiert, aus dem Event die URL des Hyperlinks extrahiert und die JEditorPane dann dazu auffordert, die in der URL referenzierte HTML-Datei anzuzeigen.

Nebenbei gesagt, können Sie auch andere Komponenten dazu bringen, HTML anzuzeigen (etwa JLabel, JButton, JToolTip und einige andere). Dazu müssen Sie den anzuzeigenden Text lediglich in <HTML> und </HTML> einfassen und schon sind mehrzeilige JToolTips und JButtons mit großen Überschriften möglich (Abb. 2).

AttributeSets

Nun schauen wir uns an, wie Sie eine Textanzeige realisieren können, in der Sie auch zur Laufzeit Ihres Programms noch weiteren formatierten Text anfügen können, etwa für eine Konsole zur Anzeige von Ergebnissen eines separat ablaufenden Prozesses, oder für ein Dialogsystem. Sie beginnen mit einer Instanz von JTextPane (das ist eine von JEditorPane abgeleitete Klasse). Diese JTextPane können Sie wie üblich in eine JScrollPane einbauen und dann irgendwo anzeigen. Zum Textanfügen arbeiten Sie allerdings mit dem Model, das ist ein StyledDocument, welches Sie sich von der JTextPane geben lassen. Die uns in erster Linie interessierende Methode lautet:

1. public void insertString(
2. int offset,
3. String str,
4. AttributeSet a)
5. throws BadLocationException

Sie erlaubt Ihnen das Anfügen eines Strings an das Ende des Dokuments, wenn Sie doc.length() als offset verwenden.

Die Formatierung des angefügten Strings geschieht durch den Parameter AttributeSet. Das ist ein Interface, welches eine Sammlung von Keys und Values beschreibt. Die Klasse SimpleAttributeSet implementiert nicht nur dieses Interface, sondern sogar auch das Interface MutableAttributeSet, was Ihnen das Hinzufügen neuer Attribute erlaubt (die Instanzen der Klasse arbeiten intern mit einer normalen Hashtable). Um nun diejenigen Keys und Values zu setzen, die tatsächlich eine Textauszeichnung bewirken, verwenden Sie am günstigsten die Hilfsklasse StyleConstants. Sie bietet Methoden wie diese:

1. public static void setBold(MutableAttributeSet a, boolean b)
2. public static void setForeground(MutableAttributeSet a, Color fg)
3. public static void setFontSize(MutableAttributeSet a, int s)

Abpictureung 3 zeigt, wie das Wort kleine in einer kleinen Schriftgröße und wie das Wort Schweinchen fett und rosa dargestellt wird (die normalen Attribute für Schweinchen eben). Listing 2 zeigt, wie die kleinen fetten rosa Schweinchen durch unterschiedliche AttributeSets realisiert werden.

Listing 2

1. import java.awt.*;
2. import javax.swing.*;
3. import javax.swing.text.*;
5. public class TextMitAttributeSets {
6. public static void main(String args[]) throws Exception {
7. JFrame frame = new JFrame("TextMitAttributeSets");
8. frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
10. JTextPane pane = new JTextPane();
11. pane.setEditable(false);
13. // Arbeite nicht mit der Pane, sondern mit dem darunterliegenden Model
14. Document doc = pane.getStyledDocument();
16. // Das erste Wort ohne irgendwelche speziellen Attribute (null)
17. doc.insertString(doc.getLength(), "Drei ",null);
19. // Baue ein AttributeSet für kleine Schrift und verwende dieses
20. // für das nächste Wort
21. SimpleAttributeSet klein = new SimpleAttributeSet();
22. StyleConstants.setFontSize(klein, 10);
23. doc.insertString(doc.getLength(), "kleine ",klein);
25. // Baue ein AttributeSet für fette rosa Schrift
26. // und verwende dieses für das letzte Wort
27. SimpleAttributeSet fettRosa = new SimpleAttributeSet();
28. StyleConstants.setBold(fettRosa, true);
29. StyleConstants.setForeground(fettRosa, Color.PINK);
30. doc.insertString(doc.getLength(),"Schweinchen", fettRosa);
32. JScrollPane scrollPane = new JScrollPane(pane);
33. frame.getContentPane().add(scrollPane, BorderLayout.CENTER);
34. frame.setSize(200, 60);
35. frame.setVisible(true);
36. }
37. }

Wenn Sie diesen Mechanismus für eine multithreaded Anwendung wie der genannten Konsole einsetzen wollen, müssen Sie darauf achten, ob in der verwendeten Implementierung des StyledDocuments die insertString()-Methode Thread-safe ist (beim DefaultStyledDocument des JDK 1.4 ist das der Fall). Andernfalls müssten Sie die Hinweise in Threads and Swing [2] beherzigen und mit den Hilfsmethoden invokeLater() oder invokeAndWait() arbeiten.

Syntax Highlighting

Eine weitere Methode von StyledDocuments ist:

1. setCharacterAttributes(
2. int offset,
3. int length,
4. AttributeSet s,
5. boolean replace)

Sie erlaubt das Anwenden von AttributeSets auf Bereiche von schon vorhandenem Text. Der boolean Parameter replace bestimmt, ob die Attribute im übergebenen AttributeSet die schon bestehenden Attribute komplett ersetzen oder ob sie zusätzlich appliziert werden.

Wenn man zusätzlich einen Mechanismus hat, um die unterschiedlichen syntaktischen Elemente (Schlüsselwörter, Kommentare etc.) eines Textes zu erkennen, kann man schnell eine einfache Anzeige mit Syntax Highlighting bauen. Das kleine Codebeispiel auf der Leser-CD benutzt eine Regular Expression von Robert D. Cameron [3], um ein XML-Dokument in seine Bestandteile zu zerlegen. Die gefundenen Teile werden dann als Elemente, Processing Instructions und CDATA-Sections identifiziert und mit jeweils anderen AttributeSets versehen (Abb. 4). Als Übungsaufgabe können Sie das Beispiel zu einem XML-Editor erweitern.

Styles

Ein Style ist ein Interface für benannte AttributeSets. Das uns schon bekannte StyledDocument erlaubt auch, neue Styles durch Angabe eines Namens zu definieren. Der Clou ist, dass neue Styles einen bestehenden anderen als Parent bekommen und dessen Attribute zur Darstellung herangezogen werden. Deswegen müssen Sie nur neue, abweichende Attribute wirklich setzen. Sie gehen dabei von einem default-Style aus, der bereits definiert ist. Die Methode addStyle() hat einen eigentlich irreführenden Namen, Sie müssen nämlich den Namen des neuen Styles und den Parent-Style übergeben und bekommen den neuen Style zurück. Diesen werden Sie in der Regel noch variieren, und zwar am günstigsten mit den Hilfsmethoden von StyleConstants (Listing 3)

Listing 3

1. // Der Default-Style als Parent der anderen wird angepaßt.
2. Style defaultStyle = doc.getStyle("default");
3. StyleConstants.setFontSize(defaultStyle, 14);
4. StyleConstants.setFontFamily(defaultStyle, "SansSerif");
6. // Zwei neue Styles mit dem Default-Style als Parent.
7. Style eingabeStyle = doc.addStyle("eingabe", defaultStyle);
8. StyleConstants.setForeground(eingabeStyle, Color.blue);
9. StyleConstants.setItalic(eingabeStyle, true);
11. Style ausgabeStyle = doc.addStyle("ausgabe", defaultStyle);
13. // Der Fehler-Style ist eine Variante des Ausgabe-Styles
14. Style fehlerStyle = doc.addStyle("fehler", ausgabeStyle);
15. StyleConstants.setForeground(fehlerStyle, Color.red);

Von einem StyledDocument können Sie sich die Styles über ihren Namen geben lassen. Damit können Sie zum Beispiel einfach eine append()-Methode implementieren, mit der ein Client ausgezeichneten Text anfügen kann ohne mit AttributeSets hantieren zu müssen (Listing 4). Das DialogSystem (Abb. 5) benutzt diese beiden Mechanismen.

Listing 4

1. // Über den Namen wird durch das StyledDocument der richtige
2. // Style ausgewählt und wie ein AttributeSet eingesetzt.
4. public void append(String text, String styleName) {
5. try {
6. doc.insertString(doc.getLength(), text, doc.getStyle(styleName));
7. }
8. catch(BadLocationException ignore){}
9. setCaretPosition(doc.getLength());
10. }

EditorKits

Die JTextPane und die JEditorPane verwenden - abhängig vom Inhaltstyp - intern unterschiedliche EditorKits, mit denen wir bisher nicht viel Kontakt hatten. Ihr praktischer Nutzwert liegt darin, dass sie Actions anbieten, die Sie direkt mit AbstractButtons (also zum Beispiel JButtons oder JMenuItems) verbinden können. Wählt ein Benutzer einen solchen Knopf oder Menüeintrag aus, wird sogleich die actionPerformed()-Methode der Action aufgerufen und darüber der Text manipuliert; Sie müssen keinen weiteren zusätzlichen Code schreiben! Ein gewisser Aufwand besteht aber darin, aus dem Array aller implementierten Actions die geeigneten herauszufinden. Eine Übersicht über die bereits vorhandenen Actions bekommen Sie mit einer einfachen Schleife wie etwa folgender:

Das Beispiel auf der Leser-CD zeigt die Actions der drei EditorKit-Klassen DefaultEditorKit, StyledEditorKit und HTMLEditorKit. Darunter sind sowohl Actions zum Bewegen des Carets und zum Auswählen von Textbereichen als auch zum Setzen von AttributeSets. Und als Sahnehäubchen ist es bei dem StyledEditorKit möglich, mit geeigneten Konstruktoren zusätzliche, parametrisierte Actions zu erzeugen, die ebenfalls an AbstractButtons angebunden werden können und neue, bisher noch nicht definierte Styles setzen. In dem Beispiel AnnotationEditorStyled (Listing 5 und Abb. 6) wird mit einer JTextPane und ihrem StyledEditorKit gearbeitet. In der Methode initActionTable() werden vom StyledEditorKit alle Actions unter ihrem Namen in einer Hashtable abgelegt. Die Methode initToolBar() erstellt zwei JButtons zum Formatieren des Textes in Fettdruck und Kursiv; als ActionListener fungieren die vorhandenen Actions mit den Namen font-bold und font-italic. Ein weiterer JButton soll die Schriftfarbe auf Rot stellen; für ihn wird eine spezielle Action erzeugt die eine Formatierung mit der im Konstruktor übergebenen Color vornimmt.

Listing 5

1. import java.awt.*;
2. import java.util.*;
3. import javax.swing.*;
4. import javax.swing.text.*;
5. import javax.swing.text.html.*;
7. class AnnotationEditorStyled extends JFrame {
9. JTextPane pane;
10. Hashtable actionTable;
12. public static void main(String args[]) throws Exception {
13. new AnnotationEditorStyled();
14. }
16. AnnotationEditorStyled() {
17. super("AnnotationEditorStyled");
18. pane = new JTextPane();
19. JScrollPane scrollPane = new JScrollPane(pane);
20. getContentPane().add(scrollPane, BorderLayout.CENTER);
21. initActionTable();
22. initToolbar();
23. setBounds(10,10,225,180);
24. setVisible(true);
25. setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
26. }
28. // Alle Actions werden unter ihrem Namen in einer Hashtable abgelegt
29. private void initActionTable() {
30. actionTable = new Hashtable();
31. StyledEditorKit editorKit = (StyledEditorKit) pane.getEditorKit();
32. Action[] actions = editorKit.getActions();
33. for (int i=0; i < actions.length; i++) {
34. Action action = actions[i];
35. actionTable.put(action.getValue(Action.NAME),action);
36. }
37. }
39. // Im Toolbar werden drei Knöpfe an drei Actions angebunden.
40. private void initToolbar() {
41. JToolBar toolBar = new JToolBar();
43. // Ein Knopf an die vorhandene Action "font-bold"
44. JButton boldButton = new JButton(new ImageIcon("images/bold.gif"));
45. boldButton.addActionListener((Action)actionTable.get("font-bold"));
46. toolBar.add(boldButton);
48. // Ein Knopf an die vorhandene Action "font-italic"
49. JButton italicButton = new JButton(new ImageIcon("images/italic.gif"));
50. italicButton.addActionListener((Action)actionTable.get("font-italic"));
51. toolBar.add(italicButton);
52. getContentPane().add(toolBar, BorderLayout.NORTH);
54. // Ein Knopf an eine neu erzeugte Action, die die Vordergrundfarbe
55. // auf den im Konstruktor übergebenen Wert setzt.
56. JButton rotButton = new JButton(new ImageIcon("images/rot.gif"));
57. rotButton.addActionListener
58. (new StyledEditorKit.ForegroundAction("rot",Color.red));
59. toolBar.add(rotButton);
60. getContentPane().add(toolBar, BorderLayout.NORTH);
61. }
62. }

Eine Variante zu diesem Beispiel ist der AnnotationEditorHTML. Er verzichtet darauf, eine neue Action für die Schriftfarbe zu definieren, bedient sich aber zusätzlich der write()-Methode des EditorKits um den vom Benutzer formatierten Text auch im HTML-Quelltext auszugeben. In einer realen Anwendung würden Sie ihn möglicherweise in einer Datei oder einer Datenbank abspeichern.

Ausblick

Die Packages unter javax.swing.text beinhalten noch viele weitere Konzepte, von denen wir nicht gesprochen haben. Man kann zum Beispiel analysieren wie ein Dokument in Elemente zerfällt und durch Views dargestellt wird. Was wir allerdings in diesem kurzen Artikel behandelt haben reicht völlig aus, Texte optisch aufzuwerten und ergonomischer zu gestalten.

Literatur und Links

• [1] java.sun.com/products/jfc/tsc/articles/tictactoe/index.html
• [2] java.sun.com/products/jfc/swingdoc-archive/threads.html
• [3] www.cs.sfu.ca/~cameron/REX.html