FontMetricspublic abstract class FontMetrics extends Object implements SerializableThe FontMetrics class defines a font metrics object, which
encapsulates information about the rendering of a particular font on a
particular screen.
Note to subclassers: Since many of these methods form closed,
mutually recursive loops, you must take care that you implement
at least one of the methods in each such loop to prevent
infinite recursion when your subclass is used.
In particular, the following is the minimal suggested set of methods
to override in order to ensure correctness and prevent infinite
recursion (though other subsets are equally feasible):
- {@link #getAscent()}
- {@link #getLeading()}
- {@link #getMaxAdvance()}
- {@link #charWidth(char)}
- {@link #charsWidth(char[], int, int)}
Note that the implementations of these methods are
inefficient, so they are usually overridden with more efficient
toolkit-specific implementations.
When an application asks AWT to place a character at the position
(x, y), the character is placed so that its
reference point (shown as the dot in the accompanying image) is
put at that position. The reference point specifies a horizontal
line called the baseline of the character. In normal
printing, the baselines of characters should align.
In addition, every character in a font has an ascent, a
descent, and an advance width. The ascent is the
amount by which the character ascends above the baseline. The
descent is the amount by which the character descends below the
baseline. The advance width indicates the position at which AWT
should place the next character.
An array of characters or a string can also have an ascent, a
descent, and an advance width. The ascent of the array is the
maximum ascent of any character in the array. The descent is the
maximum descent of any character in the array. The advance width
is the sum of the advance widths of each of the characters in the
character array. The advance of a String is the
distance along the baseline of the String. This
distance is the width that should be used for centering or
right-aligning the String.
Note that the advance of a String is not necessarily
the sum of the advances of its characters measured in isolation
because the width of a character can vary depending on its context.
For example, in Arabic text, the shape of a character can change
in order to connect to other characters. Also, in some scripts,
certain character sequences can be represented by a single shape,
called a ligature. Measuring characters individually does
not account for these transformations. |
| Fields Summary |
|---|
| protected Font | fontThe actual {@link Font} from which the font metrics are
created.
This cannot be null. | | private static final long | serialVersionUID |
| Constructors Summary |
|---|
protected FontMetrics(Font font)Creates a new FontMetrics object for finding out
height and width information about the specified Font
and specific character glyphs in that Font.
this.font = font;
|
| Methods Summary |
|---|
| public int | bytesWidth(byte[] data, int off, int len)Returns the total advance width for showing the specified array
of bytes in this Font. The advance is the
distance from the leftmost point to the rightmost point on the
string's baseline. The advance of a String
is not necessarily the sum of the advances of its characters.
This is equivalent to measuring a String of the
characters in the specified range.
return stringWidth(new String(data, 0, off, len));
| | public int | charWidth(int codePoint)Returns the advance width of the specified character in this
Font. The advance is the
distance from the leftmost point to the rightmost point on the
character's baseline. Note that the advance of a
String is not necessarily the sum of the advances
of its characters.
This method doesn't validate the specified character to be a
valid Unicode code point. The caller must validate the
character value using {@link
java.lang.Character#isValidCodePoint(int)
Character.isValidCodePoint} if necessary.
if (!Character.isValidCodePoint(codePoint)) {
codePoint = 0xffff; // substitute missing glyph width
}
if (codePoint < 256) {
return getWidths()[codePoint];
} else {
char[] buffer = new char[2];
int len = Character.toChars(codePoint, buffer, 0);
return charsWidth(buffer, 0, len);
}
| | public int | charWidth(char ch)Returns the advance width of the specified character in this
Font. The advance is the
distance from the leftmost point to the rightmost point on the
character's baseline. Note that the advance of a
String is not necessarily the sum of the advances
of its characters.
Note: This method cannot handle supplementary
characters. To support all Unicode characters, including
supplementary characters, use the {@link #charWidth(int)} method.
if (ch < 256) {
return getWidths()[ch];
}
char data[] = {ch};
return charsWidth(data, 0, 1);
| | public int | charsWidth(char[] data, int off, int len)Returns the total advance width for showing the specified array
of characters in this Font. The advance is the
distance from the leftmost point to the rightmost point on the
string's baseline. The advance of a String
is not necessarily the sum of the advances of its characters.
This is equivalent to measuring a String of the
characters in the specified range.
return stringWidth(new String(data, off, len));
| | public int | getAscent()Determines the font ascent of the Font
described by this FontMetrics object. The font ascent
is the distance from the font's baseline to the top of most
alphanumeric characters. Some characters in the Font
might extend above the font ascent line.
return font.getSize();
| | public int | getDescent()Determines the font descent of the Font
described by this
FontMetrics object. The font descent is the distance
from the font's baseline to the bottom of most alphanumeric
characters with descenders. Some characters in the
Font might extend
below the font descent line.
return 0;
| | public java.awt.Font | getFont()Gets the Font described by this
FontMetrics object.
return font;
| | public int | getHeight()Gets the standard height of a line of text in this font. This
is the distance between the baseline of adjacent lines of text.
It is the sum of the leading + ascent + descent. Due to rounding
this may not be the same as getAscent() + getDescent() + getLeading().
There is no guarantee that lines of text spaced at this distance are
disjoint; such lines may overlap if some characters overshoot
either the standard ascent or the standard descent metric.
return getLeading() + getAscent() + getDescent();
| | public int | getLeading()Determines the standard leading of the
Font described by this FontMetrics
object. The standard leading, or
interline spacing, is the logical amount of space to be reserved
between the descent of one line of text and the ascent of the next
line. The height metric is calculated to include this extra space.
return 0;
| | public java.awt.font.LineMetrics | getLineMetrics(java.lang.String str, java.awt.Graphics context)Returns the {@link LineMetrics} object for the specified
String in the specified {@link Graphics} context.
return font.getLineMetrics(str, myFRC(context));
| | public java.awt.font.LineMetrics | getLineMetrics(java.lang.String str, int beginIndex, int limit, java.awt.Graphics context)Returns the {@link LineMetrics} object for the specified
String in the specified {@link Graphics} context.
return font.getLineMetrics(str, beginIndex, limit, myFRC(context));
| | public java.awt.font.LineMetrics | getLineMetrics(char[] chars, int beginIndex, int limit, java.awt.Graphics context)Returns the {@link LineMetrics} object for the specified
character array in the specified {@link Graphics} context.
return font.getLineMetrics(
chars, beginIndex, limit, myFRC(context));
| | public java.awt.font.LineMetrics | getLineMetrics(java.text.CharacterIterator ci, int beginIndex, int limit, java.awt.Graphics context)Returns the {@link LineMetrics} object for the specified
{@link CharacterIterator} in the specified {@link Graphics}
context.
return font.getLineMetrics(ci, beginIndex, limit, myFRC(context));
| | public int | getMaxAdvance()Gets the maximum advance width of any character in this
Font. The advance is the
distance from the leftmost point to the rightmost point on the
string's baseline. The advance of a String is
not necessarily the sum of the advances of its characters.
return -1;
| | public int | getMaxAscent()Determines the maximum ascent of the Font
described by this FontMetrics object. No character
extends further above the font's baseline than this height.
return getAscent();
| | public java.awt.geom.Rectangle2D | getMaxCharBounds(java.awt.Graphics context)Returns the bounds for the character with the maximum bounds
in the specified Graphics context.
return font.getMaxCharBounds(myFRC(context));
| | public int | getMaxDecent()For backward compatibility only.
return getMaxDescent();
| | public int | getMaxDescent()Determines the maximum descent of the Font
described by this FontMetrics object. No character
extends further below the font's baseline than this height.
return getDescent();
| | public java.awt.geom.Rectangle2D | getStringBounds(java.lang.String str, java.awt.Graphics context)Returns the bounds of the specified String in the
specified Graphics context. The bounds is used
to layout the String.
return font.getStringBounds(str, myFRC(context));
| | public java.awt.geom.Rectangle2D | getStringBounds(java.lang.String str, int beginIndex, int limit, java.awt.Graphics context)Returns the bounds of the specified String in the
specified Graphics context. The bounds is used
to layout the String.
return font.getStringBounds(str, beginIndex, limit,
myFRC(context));
| | public java.awt.geom.Rectangle2D | getStringBounds(char[] chars, int beginIndex, int limit, java.awt.Graphics context)Returns the bounds of the specified array of characters
in the specified Graphics context.
The bounds is used to layout the String
created with the specified array of characters,
beginIndex and limit.
return font.getStringBounds(chars, beginIndex, limit,
myFRC(context));
| | public java.awt.geom.Rectangle2D | getStringBounds(java.text.CharacterIterator ci, int beginIndex, int limit, java.awt.Graphics context)Returns the bounds of the characters indexed in the specified
CharacterIterator in the
specified Graphics context.
return font.getStringBounds(ci, beginIndex, limit,
myFRC(context));
| | public int[] | getWidths()Gets the advance widths of the first 256 characters in the
Font. The advance is the
distance from the leftmost point to the rightmost point on the
character's baseline. Note that the advance of a
String is not necessarily the sum of the advances
of its characters.
int widths[] = new int[256];
for (char ch = 0 ; ch < 256 ; ch++) {
widths[ch] = charWidth(ch);
}
return widths;
| | public boolean | hasUniformLineMetrics()Checks to see if the Font has uniform line metrics. A
composite font may consist of several different fonts to cover
various character sets. In such cases, the
FontLineMetrics objects are not uniform.
Different fonts may have a different ascent, descent, metrics and
so on. This information is sometimes necessary for line
measuring and line breaking.
return font.hasUniformLineMetrics();
| | private static native void | initIDs()Initialize JNI field and method IDs
| | private java.awt.font.FontRenderContext | myFRC(java.awt.Graphics context)
if (context instanceof Graphics2D) {
return ((Graphics2D)context).getFontRenderContext();
}
return new FontRenderContext(null, false, false);
| | public int | stringWidth(java.lang.String str)Returns the total advance width for showing the specified
String in this Font. The advance
is the distance from the leftmost point to the rightmost point
on the string's baseline.
Note that the total advance width returned from this method
does not take into account the rendering context. Therefore,
the anti-aliasing and fractional metrics hints can affect the
value of the advance. When enabling the anti-aliasing and
fractional metrics hints, use
getStringBounds(String, Graphics)
instead of this method. The advance of a String is
not necessarily the sum of the advances of its characters.
int len = str.length();
char data[] = new char[len];
str.getChars(0, len, data, 0);
return charsWidth(data, 0, len);
| | public java.lang.String | toString()Returns a representation of this FontMetrics
object's values as a String.
return getClass().getName() +
"[font=" + getFont() +
"ascent=" + getAscent() +
", descent=" + getDescent() +
", height=" + getHeight() + "]";
|
|
