Font Metrics

To get detailed size and spacing information for text rendered in a font, we can ask for a java.awt.FontMetrics object. Different systems will have different real fonts available; the available fonts may not match the font you request. Thus, a FontMetrics object presents information about a particular font on a particular system, not general information about a font. For example, if you ask for the metrics of a nine-point Monospaced font, what you get isn't some abstract truth about Monospaced fonts; you get the metrics of the font that the particular system uses for nine-point Monospaced--which may not be exactly nine point or even Monospaced.

Use the getFontMetrics() method for a Component to retrieve the FontMetrics for a Font as it would appear for that component:

public void init() { 
    ... 
    // Get the metrics for a particular font on this component 
    FontMetrics smallFont = myLabel.getFontMetrics( smallFont ); 
    ... 
} 

The Graphics object also has a getFontMetrics() method that gets the FontMetrics information for the current font in the graphics context.

public void paint( Graphics g ) { 
    // Get the metrics for the current font 
    FontMetrics fm = g.getFontMetrics(); 
   ... 
} 

The following applet, FontShow, displays a word and draws reference lines showing certain characteristics of its font, as shown in Figure 13.5. Clicking in the applet toggles the point size between a small and a large value.

import java.awt.*;
import java.awt.event.*;
public class FontShow extends java.applet.Applet { 
    static final int LPAD=25;   // Frilly line padding
    boolean bigFont = true;
    public void init() {
        addMouseListener( new MouseAdapter() {
            public void mouseClicked(MouseEvent e) {
                bigFont = !bigFont;
                repaint();
            }
        } );
    }
    public void paint( Graphics g ) {
        String message = getParameter( "word" );
        g.drawRect(0, 0, getSize().width-1, getSize().height-1);
        if ( bigFont )
            g.setFont( new Font("Dialog",Font.PLAIN,24) );
        else
            g.setFont( new Font("Dialog",Font.PLAIN,12) );
        FontMetrics metrics = g.getFontMetrics();
        int fontAscent = metrics.getMaxAscent ();
        int fontDescent = metrics.getMaxDescent();
        int messWidth = metrics.stringWidth ( message );
        // Center text
        int startX = getSize().width/2 - messWidth/2;
        int startY = getSize().height/2 - fontDescent/2 + fontAscent/2;
        g.drawString(message, startX, startY);
        g.setColor( Color.white );  // Base lines
        g.drawLine( startX-LPAD, startY, startX+messWidth+LPAD, startY );
        g.drawLine( startX, startY+ LPAD, startX, startY-fontAscent-LPAD );
        g.setColor( Color.green );  // Ascent line
        g.drawLine( startX-LPAD, startY-fontAscent, startX+messWidth+LPAD, startY-fontAscent );
        g.setColor( Color.red );    // Descent line
        g.drawLine( startX-LPAD, startY+fontDescent, startX+messWidth+LPAD, startY+fontDescent );
    }
}

Compile FontShow and run it with an applet tag like the following:

<applet height=200 width=250 code=FontShow> 
    <param name="word" value="Lemming"> 
</applet> 

The word parameter specifies the text to be displayed.

FontShow may look a bit complicated, but there's really not much to it. The bulk of the code is in paint(), which simply sets the font, draws our word, and adds a few lines to illustrate some of the font's characteristics (metrics). For fun we also catch mouse clicks (in the mouseClicked() method) and alternate the font size by setting the bigFont variable and repainting.

By default, text is rendered above and to the right of the coordinates specified in the drawString() method. If you think of that starting point as the origin of a coordinate system, we'll call the axes the "baselines" of the font. FontShow draws these lines in white. The greatest height the characters stretch above the baseline is called the ascent and is shown by a green line. Some fonts also have parts of letters that fall below the baseline. The farthest distance any character reaches below the baseline is called the descent. FontShow illustrates this with a red line.

We ask for the ascent and descent of our font with the FontMetrics getMaxAscent() and getMaxDescent() methods. We also ask for the width of our string (when rendered in this font) with the stringWidth() method. We use this information to center the word in the display area. To center the word vertically, we average the influence of the ascent and descent.

Table 13.2 provides a short list of methods that return useful font metrics.

Leading space is the padding between lines of text. The getHeight() method reports the total height of a line of text, including the leading space.