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

24.3 Eigenschaften von Schriftarten



24.3.1 Font-Informationen

Die Klasse Font besitzt Methoden, um Informationen über den aktuellen Font zu gewinnen:

public String getFamily()
public int getStyle()
public int getSize()
java.awt.Font

getFamily liefert den systemspezifischen Namen eines Fonts, getStyle den Style-Parameter und getSize die Größe des Fonts. Auf diese Weise läßt sich ein neues Font-Objekt als Variation eines bestehenden Fonts erzeugen. Das folgende Beispiel zeigt eine paint-Methode, die den zur Anzeige verwendeten Font bei jedem Aufruf um 1 Punkt vergrößert:

001 /* SchriftGroesser.inc */
002 
003 public void paint(Graphics g)
004 {
005   Font font = getFont();
006 
007   if (font.getSize() <= 64) {
008     setFont(
009       new Font(
010         font.getFamily(),
011         font.getStyle(),
012         font.getSize() + 1
013       )
014     );
015   }
016   g.drawString("Hello, World",40,100);
017 }
SchriftGroesser.inc
Listing 24.5: Vergrößern der Schriftart

Dieses Beispiel hat eine Besonderheit, denn es werden nicht die Methoden getFont und setFont der Klasse Graphics aufgerufen, sondern diejenigen aus der Fensterklasse Frame. Dadurch bleiben die Font-Informationen auch zwischen zwei Aufrufen von paint erhalten.

 Hinweis 

24.3.2 Font-Metriken

Oft benötigt man Informationen über die Größe eines einzelnen Zeichens oder eines kompletten Strings. Anders als in textbasierten Systemen ist die Größe von Schriftzeichen bei der Programmierung unter einer grafischen Oberfläche nämlich nicht konstant, sondern von der Art des Fonts, dem Ausgabegerät und vor allem von der Breite der Zeichen selbst abhängig.

Das Größenmodell von Java sieht für ein Textzeichen fünf unterschiedliche Maßzahlen vor (siehe Abbildung 24.5), die teilweise zu den im Schriftsatz verwendeten Begriffen kompatibel sind. Wichtigste Bezugsmarke für die verschiedenen Maße ist dabei die Grundlinie des Zeichens, die den oberen und unteren Teil voneinander trennt. Die Unterlänge gibt die Länge zwischen Grundlinie und unterer Begrenzung des Zeichens an. Die Oberlänge bezeichnet die Länge zwischen Grundlinie und oberem Rand des Zeichens. Die Breite eines Zeichens ist der Abstand vom linken Rand des Zeichens bis zum linken Rand des darauffolgenden Zeichens. Der Zeilenabstand ist der Abstand zwischen dem unteren Rand einer Zeile und dem oberen Rand der nächsten Zeile. Die Höhe ist die Summe aus Oberlänge, Unterlänge und Zeilenabstand.

Abbildung 24.5: Größenmaßzahlen für Fonts in Java

Zur Bestimmung der Größeneigenschaften von Zeichen wird die Klasse FontMetrics verwendet. FontMetrics ist eine abstrakte Klasse, die nicht direkt instanziert werden kann. Statt dessen wird sie durch Aufruf der Methode getFontMetrics aus dem Grafikkontext gewonnen:

public FontMetrics getFontMetrics(Font font)
public FontMetrics getFontMetrics()
java.awt.Toolkit

Die parameterlose Variante dient dazu, Metriken zum aktuellen Font zu ermitteln, an die andere kann der zu untersuchende Font als Argument übergeben werden. Nun stehen Methoden zur Verfügung, die zur Bestimmung der genannten Eigenschaften aufgerufen werden können. Nachfolgend werden die wichtigsten von ihnen vorgestellt.

public int charWidth(char ch)

public int stringWidth(String s)
java.awt.FontMetrics

Mit charWidth wird die Breite eines einzelnen Zeichens ch bestimmt, mit stringWidth die eines kompletten Strings. Der Rückgabewert dieser Methoden wird dabei stets in Bildschirmpixeln angegeben. Bei der Anwendung von stringWidth werden auch Unterschneidungen oder andere Sonderbehandlungen berücksichtigt, die bei der Ausgabe der Zeichenkette erfolgen würden.

public int getAscent()

public int getDescent()

public int getHeight()

public int getLeading()
java.awt.FontMetrics

getAscent liefert die Oberlänge des Fonts, getDescent die Unterlänge, getLeading den Zeilenabstand und getHeight die Höhe. Obwohl diese Informationen für die meisten Zeichen des ausgewählten Fonts gültig sind, garantiert Java nicht, daß dies für alle Zeichen der Fall ist. Insbesondere kann es einzelne Zeichen geben, die eine größere Ober- oder Unterlänge haben. Zur Behandlung dieser Sonderfälle gibt es zusätzliche Methoden in FontMetrics, die hier nicht näher behandelt werden sollen.

Das nachfolgende Beispiel zeigt eine paint-Methode, die einige Schriftzeichen in 72 Punkt Größe zusammen mit einem 10*10 Pixel großen Koordinatengitter ausgibt. Zusätzlich gibt das Programm die Font-Metriken aus:

001 /* Fontmetriken.inc */
002 
003 public void paint(Graphics g)
004 {
005   Font font = new Font("TimesRoman",Font.PLAIN,72);
006 
007   //---Linien
008   g.setColor(Color.blue);
009   for (int x = 10; x <= 260; x += 10) {
010     g.drawLine(x,30,x,130);
011   }
012   for (int y = 30; y <= 130; y += 10) {
013     g.drawLine(10,y,260,y);
014   }
015   //---Schrift
016   g.setColor(Color.black);
017   g.drawLine(0,100,270,100);
018   g.setFont(font);
019   g.drawString("mgdAW",10,100);
020   //---Font-Metriken
021   FontMetrics fm = getFontMetrics(font);
022   System.out.println("Oberlänge     = " + fm.getAscent());
023   System.out.println("Unterlänge    = " + fm.getDescent());
024   System.out.println("Höhe          = " + fm.getHeight());
025   System.out.println("Zeilenabstand = " + fm.getLeading());
026   System.out.println("---");
027   System.out.println("Breite(m)     = " + fm.charWidth('m'));
028   System.out.println("Breite(g)     = " + fm.charWidth('g'));
029   System.out.println("Breite(d)     = " + fm.charWidth('d'));
030   System.out.println("Breite(A)     = " + fm.charWidth('A'));
031   System.out.println("Breite(W)     = " + fm.charWidth('W'));
032   System.out.println("---");
033 }
Fontmetriken.inc
Listing 24.6: Anzeige von Font-Metriken

Die Grafikausgabe des Programms ist wie folgt:

Abbildung 24.6: Anzeige von Font-Metriken

Zusätzlich werden die Font-Metriken in das Textfenster geschrieben:

Oberlänge     = 73
Unterlänge    = 16
Höhe          = 93
Zeilenabstand = 4
---
Breite(m)     = 55
Breite(g)     = 35
Breite(d)     = 36
Breite(A)     = 52
Breite(W)     = 68

Als weitere Anwendung der Font-Metriken wollen wir Listing 24.1 wie versprochen komplettieren und den Text zentriert ausgeben:

001 /* Zentriert.inc */
002 
003 public void paint(Graphics g)
004 {
005   int maxX=getSize().width-getInsets().left-getInsets().right;
006   int maxY=getSize().height-getInsets().top-getInsets().bottom;
007   String s="Die Client-Area ist "+maxX+"*"+maxY+" Pixel groß";
008   FontMetrics fm = g.getFontMetrics();
009   int slen = fm.stringWidth(s);
010   g.drawString(
011     s,
012     getInsets().left + ((maxX - slen)/2),
013     getInsets().top  + (maxY/2)
014   );
015 }
Zentriert.inc
Listing 24.7: Zentrierte Textausgabe

Die Programmausgabe ist:

Abbildung 24.7: Zentrierte Textausgabe


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