src/java.desktop/share/classes/java/awt/FontMetrics.java - master - githubmirror/riscv-port

src/java.desktop/share/classes/java/awt/FontMetrics.java
691 строка29 KB
Magnus Ihse Bursie
8285306: Fix typos in java.desktop
18 окт 2022, 20:08
18 окт 2022, 20:082a799e5
/*
 * Copyright (c) 1995, 2021, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

package java.awt;

import java.awt.font.FontRenderContext;
import java.awt.font.LineMetrics;
import java.awt.geom.Rectangle2D;
import java.io.Serial;
import java.text.CharacterIterator;

/**
 * The {@code FontMetrics} class defines a font metrics object, which
 * encapsulates information about the rendering of a particular font on a
 * particular screen.
 * <p>
 * <b>Note to subclassers</b>: 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):
 * <ul>
 * <li>{@link #getAscent()}
 * <li>{@link #getLeading()}
 * <li>{@link #getMaxAdvance()}
 * <li>{@link #charWidth(char)}
 * <li>{@link #charsWidth(char[], int, int)}
 * </ul>
 * <p>
 * <img src="doc-files/FontMetrics-1.gif" alt="The letter 'p' showing its 'reference point'"
 * style="border:15px; float:right; margin: 7px 10px;">
 * Note that the implementations of these methods are
 * inefficient, so they are usually overridden with more efficient
 * toolkit-specific implementations.
 * <p>
 * When an application asks to place a character at the position
 * (<i>x</i>,&nbsp;<i>y</i>), 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 <i>baseline</i> of the character. In normal
 * printing, the baselines of characters should align.
 * <p>
 * In addition, every character in a font has an <i>ascent</i>, a
 * <i>descent</i>, and an <i>advance width</i>. 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.
 * <p>
 * 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 {@code String} is the
 * distance along the baseline of the {@code String}.  This
 * distance is the width that should be used for centering or
 * right-aligning the {@code String}.
 * <p>Note that the advance of a {@code 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 <em>ligature</em>.  Measuring characters individually does
 * not account for these transformations.
 * <p>Font metrics are baseline-relative, meaning that they are
 * generally independent of the rotation applied to the font (modulo
 * possible grid hinting effects).  See {@link java.awt.Font Font}.
 *
 * @author      Jim Graham
 * @see         java.awt.Font
 * @since       1.0
 */
public abstract class FontMetrics implements java.io.Serializable {

    static {
        /* ensure that the necessary native libraries are loaded */
        Toolkit.loadLibraries();
        if (!GraphicsEnvironment.isHeadless()) {
            initIDs();
        }
    }

    private static final FontRenderContext
        DEFAULT_FRC = new FontRenderContext(null, false, false);

    /**
     * The actual {@link Font} from which the font metrics are
     * created.
     * This cannot be null.
     *
     * @serial
     * @see #getFont()
     */
    protected Font font;

    /**
     * Use serialVersionUID from JDK 1.1 for interoperability.
     */
    @Serial
    private static final long serialVersionUID = 1681126225205050147L;

    /**
     * Creates a new {@code FontMetrics} object for finding out
     * height and width information about the specified {@code Font}
     * and specific character glyphs in that {@code Font}.
     * @param     font the {@code Font}
     * @see       java.awt.Font
     */
    protected FontMetrics(Font font) {
        this.font = font;
    }

    /**
     * Gets the {@code Font} described by this
     * {@code FontMetrics} object.
     * @return    the {@code Font} described by this
     * {@code FontMetrics} object.
     */
    public Font getFont() {
        return font;
    }

    /**
     * Gets the {@code FontRenderContext} used by this
     * {@code FontMetrics} object to measure text.
     * <p>
     * Note that methods in this class which take a {@code Graphics}
     * parameter measure text using the {@code FontRenderContext}
     * of that {@code Graphics} object, and not this
     * {@code FontRenderContext}
     * @return    the {@code FontRenderContext} used by this
     * {@code FontMetrics} object.
     * @since 1.6
     */
    public FontRenderContext getFontRenderContext() {
        return DEFAULT_FRC;
    }

    /**
     * Determines the <em>standard leading</em> of the
     * {@code Font} described by this {@code 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    the standard leading of the {@code Font}.
     * @see   #getHeight()
     * @see   #getAscent()
     * @see   #getDescent()
     */
    public int getLeading() {
        return 0;
    }

    /**
     * Determines the <em>font ascent</em> of the {@code Font}
     * described by this {@code FontMetrics} object. The font ascent
     * is the distance from the font's baseline to the top of most
     * alphanumeric characters. Some characters in the {@code Font}
     * might extend above the font ascent line.
     * @return     the font ascent of the {@code Font}.
     * @see        #getMaxAscent()
     */
    public int getAscent() {
        return font.getSize();
    }

    /**
     * Determines the <em>font descent</em> of the {@code Font}
     * described by this
     * {@code 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
     * {@code Font} might extend
     * below the font descent line.
     * @return     the font descent of the {@code Font}.
     * @see        #getMaxDescent()
     */
    public int getDescent() {
        return 0;
    }

    /**
     * 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    the standard height of the font.
     * @see       #getLeading()
     * @see       #getAscent()
     * @see       #getDescent()
     */
    public int getHeight() {
        return getLeading() + getAscent() + getDescent();
    }

    /**
     * Determines the maximum ascent of the {@code Font}
     * described by this {@code FontMetrics} object.  No character
     * extends further above the font's baseline than this height.
     * @return    the maximum ascent of any character in the
     * {@code Font}.
     * @see       #getAscent()
     */
    public int getMaxAscent() {
        return getAscent();
    }

    /**
     * Determines the maximum descent of the {@code Font}
     * described by this {@code FontMetrics} object.  No character
     * extends further below the font's baseline than this height.
     * @return    the maximum descent of any character in the
     * {@code Font}.
     * @see       #getDescent()
     */
    public int getMaxDescent() {
        return getDescent();
    }

    /**
     * For backward compatibility only.
     * @return    the maximum descent of any character in the
     * {@code Font}.
     * @see #getMaxDescent()
     * @deprecated As of JDK version 1.1.1,
     * replaced by {@code getMaxDescent()}.
     */
    @Deprecated
    public int getMaxDecent() {
        return getMaxDescent();
    }

    /**
     * Returns an estimate of the maximum advance width of any character
     * in the {@code Font} described by this {@code FontMetrics} object,
     * with important caveats, enumerated below.
     * <p>
     * The advance is the distance from the leftmost point used to position
     * the character to the rightmost point along the baseline.
     * This is not the same thing as the visible width of the glyph image
     * representing the character.
     * <p>
     * The advance of a {@code String} is not necessarily the sum of the
     * advances of its characters. It may differ substantially if
     * complex text layout is required for proper rendering.
     * <p>
     * Some of the caveats of the reported value include
     * <ul>
     * <li> The returned value is relying upon information from some
     * underlying system font, and the correctness of that information
     * is outside of AWT's control.
     * <li> When specific characters are mapped into glyphs
     * in some rendering context, instructions in the font itself
     * together with the rasterization process may cause some glyph
     * to have a wider advance than reported.
     * <li> When a font is requested in some style, eg {@code Font.BOLD},
     * for which no exact match is available, then techniques to satisfy
     * the requested rendering may similarly result in glyphs that are
     * wider than the reported maximum.
     * <li> Depending on the implementation, an AWT logical font or
     * physical font may need to locate some characters from one or more
     * "fall back" fonts, when the primary underlying physical font does not
     * support the character. These fonts may not all be known or considered
     * in the calculation of the reported maximum advance. It is common
     * for the design center of such fall back fonts to be for a different
     * script than the design center of the primary font, so their
     * advances can be quite different. This can also lead to the
     * unexpected result that a font such as {@code Font.MONOSPACED} can
     * render glyphs that are not all the same width.
     * </ul>
     * None of these caveats are exposed as they are all implementation details,
     * and there is no practical way to determine when these are in effect.
     * An application which needs a better estimate of the maximum advance,
     * and knows the subset of characters it expects to display can query
     * the advance of each such character to find the widest, however,
     * as discussed above, since the displayed width of a {@code String}
     * is not necessarily the sum of the advances the value still needs
     * to be used with caution.
     * <p>
     * In summary, this method makes no absolute guarantee, nor can
     * it even make a guarantee to be correct within some margin of error.
     * So it should be used at most only for estimating the total space
     * sufficient to display some number of as yet unknown characters from
     * the font. And that might be either an overestimate, or an
     * underestimate depending on the specific text and rendering context.
     * @return    an estimate of the maximum advance width of any character
     *            in the {@code Font}, or {@code -1} if the
     *            maximum advance width is not known.
     */
    public int getMaxAdvance() {
        return -1;
    }

    /**
     * Returns the advance width of the specified character in this
     * {@code 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
     * {@code String} is not necessarily the sum of the advances
     * of its characters.
     *
     * <p>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.
     *
     * @param codePoint the character (Unicode code point) to be measured
     * @return    the advance width of the specified character
     *            in the {@code Font} described by this
     *            {@code FontMetrics} object.
     * @see   #charsWidth(char[], int, int)
     * @see   #stringWidth(String)
     */
    public int charWidth(int codePoint) {
        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);
        }
    }

    /**
     * Returns the advance width of the specified character in this
     * {@code 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
     * {@code String} is not necessarily the sum of the advances
     * of its characters.
     *
     * <p><b>Note:</b> This method cannot handle <a
     * href="../../../java.base/java/lang/Character.html#supplementary">
     * supplementary characters</a>.
     * To support all Unicode characters, including
     * supplementary characters, use the {@link #charWidth(int)} method.
     *
     * @param ch the character to be measured
     * @return     the advance width of the specified character
     *                  in the {@code Font} described by this
     *                  {@code FontMetrics} object.
     * @see        #charsWidth(char[], int, int)
     * @see        #stringWidth(String)
     */
    public int charWidth(char ch) {
        if (ch < 256) {
            return getWidths()[ch];
        }
        char[] data = {ch};
        return charsWidth(data, 0, 1);
    }

    /**
     * Returns the total advance width for showing the specified
     * {@code String} in this {@code Font}.  The advance
     * is the distance from the leftmost point to the rightmost point
     * on the string's baseline.
     * <p>
     * Note that the advance of a {@code String} is
     * not necessarily the sum of the advances of its characters.
     * @param str the {@code String} to be measured
     * @return    the advance width of the specified {@code String}
     *                  in the {@code Font} described by this
     *                  {@code FontMetrics}.
     * @throws NullPointerException if str is null.
     * @see       #bytesWidth(byte[], int, int)
     * @see       #charsWidth(char[], int, int)
     * @see       #getStringBounds(String, Graphics)
     */
    public int stringWidth(String str) {
        int len = str.length();
        char[] data = new char[len];
        str.getChars(0, len, data, 0);
        return charsWidth(data, 0, len);
    }

    /**
     * Returns the total advance width for showing the specified array
     * of characters in this {@code Font}.  The advance is the
     * distance from the leftmost point to the rightmost point on the
     * string's baseline.  The advance of a {@code String}
     * is not necessarily the sum of the advances of its characters.
     * This is equivalent to measuring a {@code String} of the
     * characters in the specified range.
     * @param data the array of characters to be measured
     * @param off the start offset of the characters in the array
     * @param len the number of characters to be measured from the array
     * @return    the advance width of the subarray of the specified
     *               {@code char} array in the font described by
     *               this {@code FontMetrics} object.
     * @throws    NullPointerException if {@code data} is null.
     * @throws    IndexOutOfBoundsException if the {@code off}
     *            and {@code len} arguments index characters outside
     *            the bounds of the {@code data} array.
     * @see       #charWidth(int)
     * @see       #charWidth(char)
     * @see       #bytesWidth(byte[], int, int)
     * @see       #stringWidth(String)
     */
    public int charsWidth(char[] data, int off, int len) {
        return stringWidth(new String(data, off, len));
    }

    /**
     * Returns the total advance width for showing the specified array
     * of bytes in this {@code Font}.  The advance is the
     * distance from the leftmost point to the rightmost point on the
     * string's baseline.  The advance of a {@code String}
     * is not necessarily the sum of the advances of its characters.
     * This is equivalent to measuring a {@code String} of the
     * characters in the specified range.
     * @param data the array of bytes to be measured
     * @param off the start offset of the bytes in the array
     * @param len the number of bytes to be measured from the array
     * @return    the advance width of the subarray of the specified
     *               {@code byte} array in the {@code Font}
     *                  described by
     *               this {@code FontMetrics} object.
     * @throws    NullPointerException if {@code data} is null.
     * @throws    IndexOutOfBoundsException if the {@code off}
     *            and {@code len} arguments index bytes outside
     *            the bounds of the {@code data} array.
     * @see       #charsWidth(char[], int, int)
     * @see       #stringWidth(String)
     */
    @SuppressWarnings("deprecation")
    public int bytesWidth(byte[] data, int off, int len) {
        return stringWidth(new String(data, 0, off, len));
    }

    /**
     * Gets the advance widths of the first 256 characters in the
     * {@code 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
     * {@code String} is not necessarily the sum of the advances
     * of its characters.
     * @return    an array storing the advance widths of the
     *                 characters in the {@code Font}
     *                 described by this {@code FontMetrics} object.
     */
    public int[] getWidths() {
        int[] widths = new int[256];
        for (char ch = 0 ; ch < 256 ; ch++) {
            widths[ch] = charWidth(ch);
        }
        return widths;
    }

    /**
     * Checks to see if the {@code Font} has uniform line metrics.  A
     * composite font may consist of several different fonts to cover
     * various character sets.  In such cases, the
     * {@code 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 {@code true} if the font has uniform line metrics;
     * {@code false} otherwise.
     * @see java.awt.Font#hasUniformLineMetrics()
     */
    public boolean hasUniformLineMetrics() {
        return font.hasUniformLineMetrics();
    }

    /**
     * Returns the {@link LineMetrics} object for the specified
     * {@code String} in the specified {@link Graphics} context.
     * @param str the specified {@code String}
     * @param context the specified {@code Graphics} context
     * @return a {@code LineMetrics} object created with the
     * specified {@code String} and {@code Graphics} context.
     * @see java.awt.Font#getLineMetrics(String, FontRenderContext)
     */
    public LineMetrics getLineMetrics( String str, Graphics context) {
        return font.getLineMetrics(str, myFRC(context));
    }

    /**
     * Returns the {@link LineMetrics} object for the specified
     * {@code String} in the specified {@link Graphics} context.
     * @param str the specified {@code String}
     * @param beginIndex the initial offset of {@code str}
     * @param limit the end offset of {@code str}
     * @param context the specified {@code Graphics} context
     * @return a {@code LineMetrics} object created with the
     * specified {@code String} and {@code Graphics} context.
     * @see java.awt.Font#getLineMetrics(String, int, int, FontRenderContext)
     */
    public LineMetrics getLineMetrics( String str,
                                            int beginIndex, int limit,
                                            Graphics context) {
        return font.getLineMetrics(str, beginIndex, limit, myFRC(context));
    }

    /**
     * Returns the {@link LineMetrics} object for the specified
     * character array in the specified {@link Graphics} context.
     * @param chars the specified character array
     * @param beginIndex the initial offset of {@code chars}
     * @param limit the end offset of {@code chars}
     * @param context the specified {@code Graphics} context
     * @return a {@code LineMetrics} object created with the
     * specified character array and {@code Graphics} context.
     * @see java.awt.Font#getLineMetrics(char[], int, int, FontRenderContext)
     */
    public LineMetrics getLineMetrics(char [] chars,
                                            int beginIndex, int limit,
                                            Graphics context) {
        return font.getLineMetrics(
                                chars, beginIndex, limit, myFRC(context));
    }

    /**
     * Returns the {@link LineMetrics} object for the specified
     * {@link CharacterIterator} in the specified {@link Graphics}
     * context.
     * @param ci the specified {@code CharacterIterator}
     * @param beginIndex the initial offset in {@code ci}
     * @param limit the end index of {@code ci}
     * @param context the specified {@code Graphics} context
     * @return a {@code LineMetrics} object created with the
     * specified arguments.
     * @see java.awt.Font#getLineMetrics(CharacterIterator, int, int, FontRenderContext)
     */
    public LineMetrics getLineMetrics(CharacterIterator ci,
                                            int beginIndex, int limit,
                                            Graphics context) {
        return font.getLineMetrics(ci, beginIndex, limit, myFRC(context));
    }

    /**
     * Returns the bounds of the specified {@code String} in the
     * specified {@code Graphics} context.  The bounds is used
     * to layout the {@code String}.
     * <p>Note: The returned bounds is in baseline-relative coordinates
     * (see {@link java.awt.FontMetrics class notes}).
     * @param str the specified {@code String}
     * @param context the specified {@code Graphics} context
     * @return a {@link Rectangle2D} that is the bounding box of the
     * specified {@code String} in the specified
     * {@code Graphics} context.
     * @see java.awt.Font#getStringBounds(String, FontRenderContext)
     */
    public Rectangle2D getStringBounds( String str, Graphics context) {
        return font.getStringBounds(str, myFRC(context));
    }

    /**
     * Returns the bounds of the specified {@code String} in the
     * specified {@code Graphics} context.  The bounds is used
     * to layout the {@code String}.
     * <p>Note: The returned bounds is in baseline-relative coordinates
     * (see {@link java.awt.FontMetrics class notes}).
     * @param str the specified {@code String}
     * @param beginIndex the offset of the beginning of {@code str}
     * @param limit the end offset of {@code str}
     * @param context the specified {@code Graphics} context
     * @return a {@code Rectangle2D} that is the bounding box of the
     * specified {@code String} in the specified
     * {@code Graphics} context.
     * @see java.awt.Font#getStringBounds(String, int, int, FontRenderContext)
     */
    public Rectangle2D getStringBounds( String str,
                                        int beginIndex, int limit,
                                        Graphics context) {
        return font.getStringBounds(str, beginIndex, limit,
                                        myFRC(context));
    }

   /**
     * Returns the bounds of the specified array of characters
     * in the specified {@code Graphics} context.
     * The bounds is used to layout the {@code String}
     * created with the specified array of characters,
     * {@code beginIndex} and {@code limit}.
     * <p>Note: The returned bounds is in baseline-relative coordinates
     * (see {@link java.awt.FontMetrics class notes}).
     * @param chars an array of characters
     * @param beginIndex the initial offset of the array of
     * characters
     * @param limit the end offset of the array of characters
     * @param context the specified {@code Graphics} context
     * @return a {@code Rectangle2D} that is the bounding box of the
     * specified character array in the specified
     * {@code Graphics} context.
     * @see java.awt.Font#getStringBounds(char[], int, int, FontRenderContext)
     */
    public Rectangle2D getStringBounds( char [] chars,
                                        int beginIndex, int limit,
                                        Graphics context) {
        return font.getStringBounds(chars, beginIndex, limit,
                                        myFRC(context));
    }

   /**
     * Returns the bounds of the characters indexed in the specified
     * {@code CharacterIterator} in the
     * specified {@code Graphics} context.
     * <p>Note: The returned bounds is in baseline-relative coordinates
     * (see {@link java.awt.FontMetrics class notes}).
     * @param ci the specified {@code CharacterIterator}
     * @param beginIndex the initial offset in {@code ci}
     * @param limit the end index of {@code ci}
     * @param context the specified {@code Graphics} context
     * @return a {@code Rectangle2D} that is the bounding box of the
     * characters indexed in the specified {@code CharacterIterator}
     * in the specified {@code Graphics} context.
     * @see java.awt.Font#getStringBounds(CharacterIterator, int, int, FontRenderContext)
     */
    public Rectangle2D getStringBounds(CharacterIterator ci,
                                        int beginIndex, int limit,
                                        Graphics context) {
        return font.getStringBounds(ci, beginIndex, limit,
                                        myFRC(context));
    }

    /**
     * Returns the bounds for the character with the maximum bounds
     * in the specified {@code Graphics} context.
     * @param context the specified {@code Graphics} context
     * @return a {@code Rectangle2D} that is the
     * bounding box for the character with the maximum bounds.
     * @see java.awt.Font#getMaxCharBounds(FontRenderContext)
     */
    public Rectangle2D getMaxCharBounds(Graphics context) {
        return font.getMaxCharBounds(myFRC(context));
    }

    private FontRenderContext myFRC(Graphics context) {
        if (context instanceof Graphics2D) {
            return ((Graphics2D)context).getFontRenderContext();
        }
        return DEFAULT_FRC;
    }


    /**
     * Returns a representation of this {@code FontMetrics}
     * object's values as a {@code String}.
     * @return    a {@code String} representation of this
     * {@code FontMetrics} object.
     */
    public String toString() {
        return getClass().getName() +
            "[font=" + getFont() +
            "ascent=" + getAscent() +
            ", descent=" + getDescent() +
            ", height=" + getHeight() + "]";
    }

    /**
     * Initialize JNI field and method IDs
     */
    private static native void initIDs();
}