Titel | Inhalt | Suchen | Index | DOC | Handbuch der Java-Programmierung, 3. Auflage
<< | < | > | >> | API | Kapitel 24 - Textausgabe

## 24.2 Unterschiedliche Schriftarten

- 24.2 Unterschiedliche Schriftarten
  - 24.2.1 Font-Objekte
  - 24.2.2 Standardschriftarten

### 24.2.1 Font-Objekte

Führt man die Schriftausgabe wie bisher besprochen durch, werden die Texte in einem systemabhängigen Standard-Font ausgegeben. Soll ein anderer Font zur Textausgabe verwendet werden, so muß zunächst ein passendes Objekt der Klasse `Font` erzeugt und dem verwendeten `Graphics`-Objekt zugewiesen werden:

    public void setFont(Font font)

    public Font getFont()
| java.awt.Graphics

Die Methode `setFont` wird dazu verwendet, das `Font`-Objekt `font` in den Grafikkontext einzutragen, und mit `getFont` kann der aktuelle Font abgefragt werden.

Das Erzeugen neuer `Font`-Objekte wird über die drei Parameter `name`, `style` und `size` des Konstruktors der Klasse `Font` gesteuert:

    public Font(String name, int style, int size)
| java.awt.Font

Der Parameter `name` gibt den Namen des gewünschten Fonts an. In allen Java-Systemen sollten die Namen `SansSerif` (früher `Helvetica`), `Serif` (früher `TimesRoman`) und `Monospaced` (früher `Courier`) unterstützt werden. Sie stehen für die systemspezifischen Proportionalzeichensätze der Familien `Helvetica` und `TimesRoman` bzw. für die nichtproportionale Familie `Courier`. Unter Windows werden diese Standardnamen auf die True-Type-Fonts `Arial`, `Times New Roman` und `Courier New` abgebildet.

|  |  |  | Der zweite und dritte Parameter des Konstruktors sind beide vom Typ `int`. Ein beliebter Fehler besteht darin, beide zu verwechseln und so die Angaben für die Größe und die Textattribute zu vertauschen. Leider kann der Fehler vom Compiler nicht gefunden werden, sondern wird frühestens zur Laufzeit entdeckt. Selbst dann wird er leicht mit dem Fall verwechselt, daß die gewünschten Schriftarten bzw. Attribute auf dem Zielsystem nicht installiert sind. Beim Erzeugen von `Font`-Objekten ist also einige Vorsicht geboten. |  |
Warnung

|  |  |  | Schriften sind generell recht unportabel, deshalb ist bei ihrer Verwendung Vorsicht angebracht. Insbesondere bei der Verwendung von systemspezifischen Schriftarten kann es sein, daß der Font-Mapper eines anderen Systems eine völlig verkehrte Schrift auswählt und die Ausgabe des Programms dann unbrauchbar wird. Werden nur die genannten Standardschriften verwendet, so sollte die Schriftausgabe auf allen unterstützten Java-Systemen zumindest lesbar bleiben. Die alten Schriftnamen `Helvetica`, `TimesRoman` und `Courier` aus dem JDK 1.0 werden zwar noch unterstützt, sind aber als `deprecated` gekennzeichnet und sollten daher nicht mehr verwendet werden. |  |
Warnung

Der Parameter `style` wird verwendet, um auszuwählen, ob ein Font in seiner Standardausprägung, fett oder kursiv angezeigt werden soll. Java stellt dafür die in Tabelle 24.1 aufgeführten numerischen Konstanten zur Verfügung. Die Werte BOLD und ITALIC können auch gemeinsam verwendet werden, indem beide Konstanten addiert werden.

Name | Wert | Bedeutung
`Font.PLAIN` | 0 | Standard-Font
`Font.BOLD` | 1 | Fett
`Font.ITALIC` | 2 | Kursiv

Tabelle 24.1: Style-Parameter

Der dritte Parameter des Konstruktors gibt die Größe der gewünschten Schriftart in Punkt an. Übliche Punktgrößen für die Ausgabe von Text sind 10 oder 12 Punkt.

Das folgende Beispiel gibt die drei Standardschriften in 36 Punkt aus:

    001 /* Schriften.inc */
    002
    003 public void paint(Graphics g)
    004 {
    005   Font font;
    006   String[] arfonts = {"Serif","SansSerif","Monospaced"};
    007
    008   for (int i=0; i<arfonts.length; ++i) {
    009     font = new Font(arfonts[i],Font.PLAIN,36);
    010     g.setFont(font);
    011     g.drawString(arfonts[i],10,30 + (i+1)*(36+5));
    012   }
    013 }
| Schriften.inc

Listing 24.2: Ausgabe verschiedener Schriften

Abbildung 24.3: Ausgabe verschiedener Fonts

|  | Die Abbildung von Schriftnamen im JDK auf die dazu passenden Schriften des Betriebssystems wird durch die Datei font.properties im lib-Verzeichnis des JDK gesteuert, die zur Laufzeit vom AWT interpretiert wird. Werden hier Anpassungen vorgenommen, so ändert sich die Darstellung der Standardschriften. |  |
Hinweis

### 24.2.2 Standardschriftarten

Es gibt im AWT eine Klasse `Toolkit`, die als Hilfsklasse bei der Abbildung der portablen AWT-Eigenschaften dient. `Toolkit` ist standardmäßig abstrakt, wird aber von jeder AWT-Implementierung konkretisiert und den Anwendungen über die Klassenmethode `getDefaultToolkit` zur Verfügung gestellt. Während die meisten Methoden von `Toolkit` nur für Implementatoren von AWT-Portierungen von Interesse sind, gibt es auch einige Methoden, die in der Anwendung sinnvoll verwendet werden können. Eine dieser Methoden ist `getFontList`:

    public String[] getFontList()
| java.awt.Toolkit

Diese Methode liefert ein Array von Strings mit den Namen der Standardschriftarten, die in der vorliegenden AWT-Implementierung verfügbar sind.

Die folgende `paint`-Methode listet alle verfügbaren Standardschriften auf dem Bildschirm auf:

    001 /* Standardschriften.inc */
    002
    003 public void paint(Graphics g)
    004 {
    005   Font font;
    006   String[] arfonts = Toolkit.getDefaultToolkit().getFontList();
    007
    008   for (int i=0; i<arfonts.length; ++i) {
    009     font = new Font(arfonts[i],Font.PLAIN,36);
    010     g.setFont(font);
    011     g.drawString(arfonts[i],10,(i+1)*(36+5));
    012   }
    013 }
| Standardschriften.inc

Listing 24.3: Auflistung aller Standardschriften

|  |  |  | Mit dem JDK 1.2 wurde die Methode `getFontList` als `deprecated` markiert. Sie wird ersetzt durch die Methode `getAvailableFontFamilyNames` der Klasse `GraphicsEnvironment`, die im JDK 1.2 dazu dient, die verfügbaren Grafikgeräte und -konfigurationen zu beschreiben. Mit der statischen Methode `getLocalGraphicsEnvironment` kann das aktuelle `GraphicsEnvironment`-Objekt beschafft werden. |  |
JDK1.1-1.4

    static GraphicsEnvironment getLocalGraphicsEnvironment()

    String[] getAvailableFontFamilyNames()
| java.awt.GraphicsEnvironment

Das vorige Beispiel müßte also wie folgt geändert werden:

    001 /* Standardschriften12.inc */
    002
    003 public void paint(Graphics g)
    004 {
    005   Font font;
    006   GraphicsEnvironment ge =
    007     GraphicsEnvironment.getLocalGraphicsEnvironment();
    008   String[] arfonts = ge.getAvailableFontFamilyNames();
    009
    010   for (int i=0; i<arfonts.length; ++i) {
    011     font = new Font(arfonts[i],Font.PLAIN,36);
    012     g.setFont(font);
    013     g.drawString(arfonts[i],10,(i+1)*(36+5));
    014   }
    015 }
| Standardschriften12.inc

Listing 24.4: Auflistung der Standardschriften

Die Ausgabe des Programms ist (man muß das Fenster etwas größer ziehen, damit alle Schriften angezeigt werden):

Abbildung 24.4: Liste der Standardschriften

Die letzte Schrift ist ZapfDingbats, eine Schrift mit vorwiegend grafischen Symbolen. Da ihr Zeichensatz anders organisiert ist als bei normalen Schriften, werden lediglich eckige Kästchen ausgegeben.

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