< prev index next >

src/java.desktop/share/classes/java/awt/Font.java

Print this page

        

*** 63,83 **** import sun.font.CoreMetrics; import static sun.font.EAttribute.*; /** ! * The <code>Font</code> class represents fonts, which are used to * render text in a visible way. * A font provides the information needed to map sequences of * <em>characters</em> to sequences of <em>glyphs</em> ! * and to render sequences of glyphs on <code>Graphics</code> and ! * <code>Component</code> objects. * * <h3>Characters and Glyphs</h3> * * A <em>character</em> is a symbol that represents an item such as a letter, ! * a digit, or punctuation in an abstract way. For example, <code>'g'</code>, * LATIN SMALL LETTER G, is a character. * <p> * A <em>glyph</em> is a shape used to render a character or a sequence of * characters. In simple writing systems, such as Latin, typically one glyph * represents one character. In general, however, characters and glyphs do not --- 63,83 ---- import sun.font.CoreMetrics; import static sun.font.EAttribute.*; /** ! * The {@code Font} class represents fonts, which are used to * render text in a visible way. * A font provides the information needed to map sequences of * <em>characters</em> to sequences of <em>glyphs</em> ! * and to render sequences of glyphs on {@code Graphics} and ! * {@code Component} objects. * * <h3>Characters and Glyphs</h3> * * A <em>character</em> is a symbol that represents an item such as a letter, ! * a digit, or punctuation in an abstract way. For example, {@code 'g'}, * LATIN SMALL LETTER G, is a character. * <p> * A <em>glyph</em> is a shape used to render a character or a sequence of * characters. In simple writing systems, such as Latin, typically one glyph * represents one character. In general, however, characters and glyphs do not
*** 133,217 **** * in <a href="https://docs.oracle.com/javase/tutorial/index.html">The Java Tutorials</a> * document. * * <h3>Font Faces and Names</h3> * ! * A <code>Font</code> * can have many faces, such as heavy, medium, oblique, gothic and * regular. All of these faces have similar typographic design. * <p> * There are three different names that you can get from a ! * <code>Font</code> object. The <em>logical font name</em> is simply the * name that was used to construct the font. * The <em>font face name</em>, or just <em>font name</em> for * short, is the name of a particular font face, like Helvetica Bold. The * <em>family name</em> is the name of the font family that determines the * typographic design across several faces, like Helvetica. * <p> ! * The <code>Font</code> class represents an instance of a font face from * a collection of font faces that are present in the system resources * of the host system. As examples, Arial Bold and Courier Bold Italic ! * are font faces. There can be several <code>Font</code> objects * associated with a font face, each differing in size, style, transform * and font features. * <p> * The {@link GraphicsEnvironment#getAllFonts() getAllFonts} method ! * of the <code>GraphicsEnvironment</code> class returns an * array of all font faces available in the system. These font faces are ! * returned as <code>Font</code> objects with a size of 1, identity * transform and default font features. These ! * base fonts can then be used to derive new <code>Font</code> objects * with varying sizes, styles, transforms and font features via the ! * <code>deriveFont</code> methods in this class. * * <h3>Font and TextAttribute</h3> * ! * <p><code>Font</code> supports most ! * <code>TextAttribute</code>s. This makes some operations, such as * rendering underlined text, convenient since it is not ! * necessary to explicitly construct a <code>TextLayout</code> object. * Attributes can be set on a Font by constructing or deriving it ! * using a <code>Map</code> of <code>TextAttribute</code> values. * ! * <p>The values of some <code>TextAttributes</code> are not * serializable, and therefore attempting to serialize an instance of ! * <code>Font</code> that has such values will not serialize them. * This means a Font deserialized from such a stream will not compare * equal to the original Font that contained the non-serializable * attributes. This should very rarely pose a problem * since these attributes are typically used only in special * circumstances and are unlikely to be serialized. * * <ul> ! * <li><code>FOREGROUND</code> and <code>BACKGROUND</code> use ! * <code>Paint</code> values. The subclass <code>Color</code> is ! * serializable, while <code>GradientPaint</code> and ! * <code>TexturePaint</code> are not.</li> ! * <li><code>CHAR_REPLACEMENT</code> uses ! * <code>GraphicAttribute</code> values. The subclasses ! * <code>ShapeGraphicAttribute</code> and ! * <code>ImageGraphicAttribute</code> are not serializable.</li> ! * <li><code>INPUT_METHOD_HIGHLIGHT</code> uses ! * <code>InputMethodHighlight</code> values, which are * not serializable. See {@link java.awt.im.InputMethodHighlight}.</li> * </ul> * ! * <p>Clients who create custom subclasses of <code>Paint</code> and ! * <code>GraphicAttribute</code> can make them serializable and * avoid this problem. Clients who use input method highlights can * convert these to the platform-specific attributes for that * highlight on the current platform and set them on the Font as * a workaround. * ! * <p>The <code>Map</code>-based constructor and ! * <code>deriveFont</code> APIs ignore the FONT attribute, and it is * not retained by the Font; the static {@link #getFont} method should * be used if the FONT attribute might be present. See {@link * java.awt.font.TextAttribute#FONT} for more information.</p> * * <p>Several attributes will cause additional rendering overhead ! * and potentially invoke layout. If a <code>Font</code> has such * attributes, the <code>{@link #hasLayoutAttributes()}</code> method * will return true.</p> * * <p>Note: Font rotations can cause text baselines to be rotated. In * order to account for this (rare) possibility, font APIs are --- 133,217 ---- * in <a href="https://docs.oracle.com/javase/tutorial/index.html">The Java Tutorials</a> * document. * * <h3>Font Faces and Names</h3> * ! * A {@code Font} * can have many faces, such as heavy, medium, oblique, gothic and * regular. All of these faces have similar typographic design. * <p> * There are three different names that you can get from a ! * {@code Font} object. The <em>logical font name</em> is simply the * name that was used to construct the font. * The <em>font face name</em>, or just <em>font name</em> for * short, is the name of a particular font face, like Helvetica Bold. The * <em>family name</em> is the name of the font family that determines the * typographic design across several faces, like Helvetica. * <p> ! * The {@code Font} class represents an instance of a font face from * a collection of font faces that are present in the system resources * of the host system. As examples, Arial Bold and Courier Bold Italic ! * are font faces. There can be several {@code Font} objects * associated with a font face, each differing in size, style, transform * and font features. * <p> * The {@link GraphicsEnvironment#getAllFonts() getAllFonts} method ! * of the {@code GraphicsEnvironment} class returns an * array of all font faces available in the system. These font faces are ! * returned as {@code Font} objects with a size of 1, identity * transform and default font features. These ! * base fonts can then be used to derive new {@code Font} objects * with varying sizes, styles, transforms and font features via the ! * {@code deriveFont} methods in this class. * * <h3>Font and TextAttribute</h3> * ! * <p>{@code Font} supports most ! * {@code TextAttribute}s. This makes some operations, such as * rendering underlined text, convenient since it is not ! * necessary to explicitly construct a {@code TextLayout} object. * Attributes can be set on a Font by constructing or deriving it ! * using a {@code Map} of {@code TextAttribute} values. * ! * <p>The values of some {@code TextAttributes} are not * serializable, and therefore attempting to serialize an instance of ! * {@code Font} that has such values will not serialize them. * This means a Font deserialized from such a stream will not compare * equal to the original Font that contained the non-serializable * attributes. This should very rarely pose a problem * since these attributes are typically used only in special * circumstances and are unlikely to be serialized. * * <ul> ! * <li>{@code FOREGROUND} and {@code BACKGROUND} use ! * {@code Paint} values. The subclass {@code Color} is ! * serializable, while {@code GradientPaint} and ! * {@code TexturePaint} are not.</li> ! * <li>{@code CHAR_REPLACEMENT} uses ! * {@code GraphicAttribute} values. The subclasses ! * {@code ShapeGraphicAttribute} and ! * {@code ImageGraphicAttribute} are not serializable.</li> ! * <li>{@code INPUT_METHOD_HIGHLIGHT} uses ! * {@code InputMethodHighlight} values, which are * not serializable. See {@link java.awt.im.InputMethodHighlight}.</li> * </ul> * ! * <p>Clients who create custom subclasses of {@code Paint} and ! * {@code GraphicAttribute} can make them serializable and * avoid this problem. Clients who use input method highlights can * convert these to the platform-specific attributes for that * highlight on the current platform and set them on the Font as * a workaround. * ! * <p>The {@code Map}-based constructor and ! * {@code deriveFont} APIs ignore the FONT attribute, and it is * not retained by the Font; the static {@link #getFont} method should * be used if the FONT attribute might be present. See {@link * java.awt.font.TextAttribute#FONT} for more information.</p> * * <p>Several attributes will cause additional rendering overhead ! * and potentially invoke layout. If a {@code Font} has such * attributes, the <code>{@link #hasLayoutAttributes()}</code> method * will return true.</p> * * <p>Note: Font rotations can cause text baselines to be rotated. In * order to account for this (rare) possibility, font APIs are
*** 368,407 **** * @since 1.5 */ public static final int TYPE1_FONT = 1; /** ! * The logical name of this <code>Font</code>, as passed to the * constructor. * @since 1.0 * * @serial * @see #getName */ protected String name; /** ! * The style of this <code>Font</code>, as passed to the constructor. * This style can be PLAIN, BOLD, ITALIC, or BOLD+ITALIC. * @since 1.0 * * @serial * @see #getStyle() */ protected int style; /** ! * The point size of this <code>Font</code>, rounded to integer. * @since 1.0 * * @serial * @see #getSize() */ protected int size; /** ! * The point size of this <code>Font</code> in <code>float</code>. * * @serial * @see #getSize() * @see #getSize2D() */ --- 368,407 ---- * @since 1.5 */ public static final int TYPE1_FONT = 1; /** ! * The logical name of this {@code Font}, as passed to the * constructor. * @since 1.0 * * @serial * @see #getName */ protected String name; /** ! * The style of this {@code Font}, as passed to the constructor. * This style can be PLAIN, BOLD, ITALIC, or BOLD+ITALIC. * @since 1.0 * * @serial * @see #getStyle() */ protected int style; /** ! * The point size of this {@code Font}, rounded to integer. * @since 1.0 * * @serial * @see #getSize() */ protected int size; /** ! * The point size of this {@code Font} in {@code float}. * * @serial * @see #getSize() * @see #getSize2D() */
*** 506,544 **** */ return font2DHandle.font2D; } /** ! * Creates a new <code>Font</code> from the specified name, style and * point size. * <p> * The font name can be a font face name or a font family name. * It is used together with the style to find an appropriate font face. * When a font family name is specified, the style argument is used to * select the most appropriate face from the family. When a font face * name is specified, the face's style and the style argument are * merged to locate the best matching font from the same family. * For example if face name "Arial Bold" is specified with style ! * <code>Font.ITALIC</code>, the font system looks for a face in the * "Arial" family that is bold and italic, and may associate the font * instance with the physical font face "Arial Bold Italic". * The style argument is merged with the specified face's style, not * added or subtracted. * This means, specifying a bold face and a bold style does not * double-embolden the font, and specifying a bold face and a plain * style does not lighten the font. * <p> * If no face for the requested style can be found, the font system * may apply algorithmic styling to achieve the desired style. ! * For example, if <code>ITALIC</code> is requested, but no italic * face is available, glyphs from the plain face may be algorithmically * obliqued (slanted). * <p> * Font name lookup is case insensitive, using the case folding * rules of the US locale. * <p> ! * If the <code>name</code> parameter represents something other than a * logical font, i.e. is interpreted as a physical font face or family, and * this cannot be mapped by the implementation to a physical font or a * compatible alternative, then the font system will map the Font * instance to "Dialog", such that for example, the family as reported * by {@link #getFamily() getFamily} will be "Dialog". --- 506,544 ---- */ return font2DHandle.font2D; } /** ! * Creates a new {@code Font} from the specified name, style and * point size. * <p> * The font name can be a font face name or a font family name. * It is used together with the style to find an appropriate font face. * When a font family name is specified, the style argument is used to * select the most appropriate face from the family. When a font face * name is specified, the face's style and the style argument are * merged to locate the best matching font from the same family. * For example if face name "Arial Bold" is specified with style ! * {@code Font.ITALIC}, the font system looks for a face in the * "Arial" family that is bold and italic, and may associate the font * instance with the physical font face "Arial Bold Italic". * The style argument is merged with the specified face's style, not * added or subtracted. * This means, specifying a bold face and a bold style does not * double-embolden the font, and specifying a bold face and a plain * style does not lighten the font. * <p> * If no face for the requested style can be found, the font system * may apply algorithmic styling to achieve the desired style. ! * For example, if {@code ITALIC} is requested, but no italic * face is available, glyphs from the plain face may be algorithmically * obliqued (slanted). * <p> * Font name lookup is case insensitive, using the case folding * rules of the US locale. * <p> ! * If the {@code name} parameter represents something other than a * logical font, i.e. is interpreted as a physical font face or family, and * this cannot be mapped by the implementation to a physical font or a * compatible alternative, then the font system will map the Font * instance to "Dialog", such that for example, the family as reported * by {@link #getFamily() getFamily} will be "Dialog".
*** 675,706 **** } initFromValues(values); } /** ! * Creates a new <code>Font</code> with the specified attributes. * Only keys defined in {@link java.awt.font.TextAttribute TextAttribute} * are recognized. In addition the FONT attribute is * not recognized by this constructor * (see {@link #getAvailableAttributes}). Only attributes that have ! * values of valid types will affect the new <code>Font</code>. * <p> ! * If <code>attributes</code> is <code>null</code>, a new ! * <code>Font</code> is initialized with default values. * @see java.awt.font.TextAttribute * @param attributes the attributes to assign to the new ! * <code>Font</code>, or <code>null</code> */ public Font(Map<? extends Attribute, ?> attributes) { initFromValues(AttributeValues.fromMap(attributes, RECOGNIZED_MASK)); } /** ! * Creates a new <code>Font</code> from the specified <code>font</code>. * This constructor is intended for use by subclasses. ! * @param font from which to create this <code>Font</code>. ! * @throws NullPointerException if <code>font</code> is null * @since 1.6 */ protected Font(Font font) { if (font.values != null) { initFromValues(font.getAttributeValues().clone()); --- 675,706 ---- } initFromValues(values); } /** ! * Creates a new {@code Font} with the specified attributes. * Only keys defined in {@link java.awt.font.TextAttribute TextAttribute} * are recognized. In addition the FONT attribute is * not recognized by this constructor * (see {@link #getAvailableAttributes}). Only attributes that have ! * values of valid types will affect the new {@code Font}. * <p> ! * If {@code attributes} is {@code null}, a new ! * {@code Font} is initialized with default values. * @see java.awt.font.TextAttribute * @param attributes the attributes to assign to the new ! * {@code Font}, or {@code null} */ public Font(Map<? extends Attribute, ?> attributes) { initFromValues(AttributeValues.fromMap(attributes, RECOGNIZED_MASK)); } /** ! * Creates a new {@code Font} from the specified {@code font}. * This constructor is intended for use by subclasses. ! * @param font from which to create this {@code Font}. ! * @throws NullPointerException if {@code font} is null * @since 1.6 */ protected Font(Font font) { if (font.values != null) { initFromValues(font.getAttributeValues().clone());
*** 763,784 **** this.nonIdentityTx = values.anyNonDefault(EXTRA_MASK); this.hasLayoutAttributes = values.anyNonDefault(LAYOUT_MASK); } /** ! * Returns a <code>Font</code> appropriate to the attributes. ! * If <code>attributes</code>contains a <code>FONT</code> attribute ! * with a valid <code>Font</code> as its value, it will be * merged with any remaining attributes. See * {@link java.awt.font.TextAttribute#FONT} for more * information. * * @param attributes the attributes to assign to the new ! * <code>Font</code> ! * @return a new <code>Font</code> created with the specified * attributes ! * @throws NullPointerException if <code>attributes</code> is null. * @since 1.2 * @see java.awt.font.TextAttribute */ public static Font getFont(Map<? extends Attribute, ?> attributes) { // optimize for two cases: --- 763,784 ---- this.nonIdentityTx = values.anyNonDefault(EXTRA_MASK); this.hasLayoutAttributes = values.anyNonDefault(LAYOUT_MASK); } /** ! * Returns a {@code Font} appropriate to the attributes. ! * If {@code attributes} contains a {@code FONT} attribute ! * with a valid {@code Font} as its value, it will be * merged with any remaining attributes. See * {@link java.awt.font.TextAttribute#FONT} for more * information. * * @param attributes the attributes to assign to the new ! * {@code Font} ! * @return a new {@code Font} created with the specified * attributes ! * @throws NullPointerException if {@code attributes} is null. * @since 1.2 * @see java.awt.font.TextAttribute */ public static Font getFont(Map<? extends Attribute, ?> attributes) { // optimize for two cases:
*** 840,872 **** } return hasPerm; } /** ! * Returns a new <code>Font</code> using the specified font type ! * and input data. The new <code>Font</code> is * created with a point size of 1 and style {@link #PLAIN PLAIN}. ! * This base font can then be used with the <code>deriveFont</code> ! * methods in this class to derive new <code>Font</code> objects with * varying sizes, styles, transforms and font features. This * method does not close the {@link InputStream}. * <p> ! * To make the <code>Font</code> available to Font constructors the ! * returned <code>Font</code> must be registered in the ! * <code>GraphicsEnvironment</code> by calling * {@link GraphicsEnvironment#registerFont(Font) registerFont(Font)}. ! * @param fontFormat the type of the <code>Font</code>, which is * {@link #TRUETYPE_FONT TRUETYPE_FONT} if a TrueType resource is specified. * or {@link #TYPE1_FONT TYPE1_FONT} if a Type 1 resource is specified. ! * @param fontStream an <code>InputStream</code> object representing the * input data for the font. ! * @return a new <code>Font</code> created with the specified font type. ! * @throws IllegalArgumentException if <code>fontFormat</code> is not ! * <code>TRUETYPE_FONT</code>or<code>TYPE1_FONT</code>. ! * @throws FontFormatException if the <code>fontStream</code> data does * not contain the required font tables for the specified format. ! * @throws IOException if the <code>fontStream</code> * cannot be completely read. * @see GraphicsEnvironment#registerFont(Font) * @since 1.3 */ public static Font createFont(int fontFormat, InputStream fontStream) --- 840,872 ---- } return hasPerm; } /** ! * Returns a new {@code Font} using the specified font type ! * and input data. The new {@code Font} is * created with a point size of 1 and style {@link #PLAIN PLAIN}. ! * This base font can then be used with the {@code deriveFont} ! * methods in this class to derive new {@code Font} objects with * varying sizes, styles, transforms and font features. This * method does not close the {@link InputStream}. * <p> ! * To make the {@code Font} available to Font constructors the ! * returned {@code Font} must be registered in the ! * {@code GraphicsEnvironment} by calling * {@link GraphicsEnvironment#registerFont(Font) registerFont(Font)}. ! * @param fontFormat the type of the {@code Font}, which is * {@link #TRUETYPE_FONT TRUETYPE_FONT} if a TrueType resource is specified. * or {@link #TYPE1_FONT TYPE1_FONT} if a Type 1 resource is specified. ! * @param fontStream an {@code InputStream} object representing the * input data for the font. ! * @return a new {@code Font} created with the specified font type. ! * @throws IllegalArgumentException if {@code fontFormat} is not ! * {@code TRUETYPE_FONT} or {@code TYPE1_FONT}. ! * @throws FontFormatException if the {@code fontStream} data does * not contain the required font tables for the specified format. ! * @throws IOException if the {@code fontStream} * cannot be completely read. * @see GraphicsEnvironment#registerFont(Font) * @since 1.3 */ public static Font createFont(int fontFormat, InputStream fontStream)
*** 999,1035 **** throw new IOException("Problem reading font data."); } } /** ! * Returns a new <code>Font</code> using the specified font type ! * and the specified font file. The new <code>Font</code> is * created with a point size of 1 and style {@link #PLAIN PLAIN}. ! * This base font can then be used with the <code>deriveFont</code> ! * methods in this class to derive new <code>Font</code> objects with * varying sizes, styles, transforms and font features. ! * @param fontFormat the type of the <code>Font</code>, which is * {@link #TRUETYPE_FONT TRUETYPE_FONT} if a TrueType resource is * specified or {@link #TYPE1_FONT TYPE1_FONT} if a Type 1 resource is * specified. * So long as the returned font, or its derived fonts are referenced ! * the implementation may continue to access <code>fontFile</code> * to retrieve font data. Thus the results are undefined if the file * is changed, or becomes inaccessible. * <p> ! * To make the <code>Font</code> available to Font constructors the ! * returned <code>Font</code> must be registered in the ! * <code>GraphicsEnvironment</code> by calling * {@link GraphicsEnvironment#registerFont(Font) registerFont(Font)}. ! * @param fontFile a <code>File</code> object representing the * input data for the font. ! * @return a new <code>Font</code> created with the specified font type. ! * @throws IllegalArgumentException if <code>fontFormat</code> is not ! * <code>TRUETYPE_FONT</code>or<code>TYPE1_FONT</code>. ! * @throws NullPointerException if <code>fontFile</code> is null. ! * @throws IOException if the <code>fontFile</code> cannot be read. ! * @throws FontFormatException if <code>fontFile</code> does * not contain the required font tables for the specified format. * @throws SecurityException if the executing code does not have * permission to read from the file. * @see GraphicsEnvironment#registerFont(Font) * @since 1.5 --- 999,1035 ---- throw new IOException("Problem reading font data."); } } /** ! * Returns a new {@code Font} using the specified font type ! * and the specified font file. The new {@code Font} is * created with a point size of 1 and style {@link #PLAIN PLAIN}. ! * This base font can then be used with the {@code deriveFont} ! * methods in this class to derive new {@code Font} objects with * varying sizes, styles, transforms and font features. ! * @param fontFormat the type of the {@code Font}, which is * {@link #TRUETYPE_FONT TRUETYPE_FONT} if a TrueType resource is * specified or {@link #TYPE1_FONT TYPE1_FONT} if a Type 1 resource is * specified. * So long as the returned font, or its derived fonts are referenced ! * the implementation may continue to access {@code fontFile} * to retrieve font data. Thus the results are undefined if the file * is changed, or becomes inaccessible. * <p> ! * To make the {@code Font} available to Font constructors the ! * returned {@code Font} must be registered in the ! * {@code GraphicsEnvironment} by calling * {@link GraphicsEnvironment#registerFont(Font) registerFont(Font)}. ! * @param fontFile a {@code File} object representing the * input data for the font. ! * @return a new {@code Font} created with the specified font type. ! * @throws IllegalArgumentException if {@code fontFormat} is not ! * {@code TRUETYPE_FONT} or {@code TYPE1_FONT}. ! * @throws NullPointerException if {@code fontFile} is null. ! * @throws IOException if the {@code fontFile} cannot be read. ! * @throws FontFormatException if {@code fontFile} does * not contain the required font tables for the specified format. * @throws SecurityException if the executing code does not have * permission to read from the file. * @see GraphicsEnvironment#registerFont(Font) * @since 1.5
*** 1055,1075 **** return new Font(fontFile, fontFormat, false, null); } /** * Returns a copy of the transform associated with this ! * <code>Font</code>. This transform is not necessarily the one * used to construct the font. If the font has algorithmic * superscripting or width adjustment, this will be incorporated ! * into the returned <code>AffineTransform</code>. * <p> * Typically, fonts will not be transformed. Clients generally * should call {@link #isTransformed} first, and only call this ! * method if <code>isTransformed</code> returns true. * * @return an {@link AffineTransform} object representing the ! * transform attribute of this <code>Font</code> object. */ public AffineTransform getTransform() { /* The most common case is the identity transform. Most callers * should call isTransformed() first, to decide if they need to * get the transform, but some may not. Here we check to see --- 1055,1075 ---- return new Font(fontFile, fontFormat, false, null); } /** * Returns a copy of the transform associated with this ! * {@code Font}. This transform is not necessarily the one * used to construct the font. If the font has algorithmic * superscripting or width adjustment, this will be incorporated ! * into the returned {@code AffineTransform}. * <p> * Typically, fonts will not be transformed. Clients generally * should call {@link #isTransformed} first, and only call this ! * method if {@code isTransformed} returns true. * * @return an {@link AffineTransform} object representing the ! * transform attribute of this {@code Font} object. */ public AffineTransform getTransform() { /* The most common case is the identity transform. Most callers * should call isTransformed() first, to decide if they need to * get the transform, but some may not. Here we check to see
*** 1161,1183 **** 1.0262346f, 1.0591564f, }; /** ! * Returns the family name of this <code>Font</code>. * * <p>The family name of a font is font specific. Two fonts such as * Helvetica Italic and Helvetica Bold have the same family name, * <i>Helvetica</i>, whereas their font face names are * <i>Helvetica Bold</i> and <i>Helvetica Italic</i>. The list of * available family names may be obtained by using the * {@link GraphicsEnvironment#getAvailableFontFamilyNames()} method. * ! * <p>Use <code>getName</code> to get the logical name of the font. ! * Use <code>getFontName</code> to get the font face name of the font. ! * @return a <code>String</code> that is the family name of this ! * <code>Font</code>. * * @see #getName * @see #getFontName * @since 1.1 */ --- 1161,1183 ---- 1.0262346f, 1.0591564f, }; /** ! * Returns the family name of this {@code Font}. * * <p>The family name of a font is font specific. Two fonts such as * Helvetica Italic and Helvetica Bold have the same family name, * <i>Helvetica</i>, whereas their font face names are * <i>Helvetica Bold</i> and <i>Helvetica Italic</i>. The list of * available family names may be obtained by using the * {@link GraphicsEnvironment#getAvailableFontFamilyNames()} method. * ! * <p>Use {@code getName} to get the logical name of the font. ! * Use {@code getFontName} to get the font face name of the font. ! * @return a {@code String} that is the family name of this ! * {@code Font}. * * @see #getName * @see #getFontName * @since 1.1 */
*** 1192,1214 **** final String getFamily_NoClientCode() { return getFamily(Locale.getDefault()); } /** ! * Returns the family name of this <code>Font</code>, localized for * the specified locale. * * <p>The family name of a font is font specific. Two fonts such as * Helvetica Italic and Helvetica Bold have the same family name, * <i>Helvetica</i>, whereas their font face names are * <i>Helvetica Bold</i> and <i>Helvetica Italic</i>. The list of * available family names may be obtained by using the * {@link GraphicsEnvironment#getAvailableFontFamilyNames()} method. * ! * <p>Use <code>getFontName</code> to get the font face name of the font. * @param l locale for which to get the family name ! * @return a <code>String</code> representing the family name of the * font, localized for the specified locale. * @see #getFontName * @see java.util.Locale * @since 1.2 */ --- 1192,1214 ---- final String getFamily_NoClientCode() { return getFamily(Locale.getDefault()); } /** ! * Returns the family name of this {@code Font}, localized for * the specified locale. * * <p>The family name of a font is font specific. Two fonts such as * Helvetica Italic and Helvetica Bold have the same family name, * <i>Helvetica</i>, whereas their font face names are * <i>Helvetica Bold</i> and <i>Helvetica Italic</i>. The list of * available family names may be obtained by using the * {@link GraphicsEnvironment#getAvailableFontFamilyNames()} method. * ! * <p>Use {@code getFontName} to get the font face name of the font. * @param l locale for which to get the family name ! * @return a {@code String} representing the family name of the * font, localized for the specified locale. * @see #getFontName * @see java.util.Locale * @since 1.2 */
*** 1218,1274 **** } return getFont2D().getFamilyName(l); } /** ! * Returns the postscript name of this <code>Font</code>. ! * Use <code>getFamily</code> to get the family name of the font. ! * Use <code>getFontName</code> to get the font face name of the font. ! * @return a <code>String</code> representing the postscript name of ! * this <code>Font</code>. * @since 1.2 */ public String getPSName() { return getFont2D().getPostscriptName(); } /** ! * Returns the logical name of this <code>Font</code>. ! * Use <code>getFamily</code> to get the family name of the font. ! * Use <code>getFontName</code> to get the font face name of the font. ! * @return a <code>String</code> representing the logical name of ! * this <code>Font</code>. * @see #getFamily * @see #getFontName * @since 1.0 */ public String getName() { return name; } /** ! * Returns the font face name of this <code>Font</code>. For example, * Helvetica Bold could be returned as a font face name. ! * Use <code>getFamily</code> to get the family name of the font. ! * Use <code>getName</code> to get the logical name of the font. ! * @return a <code>String</code> representing the font face name of ! * this <code>Font</code>. * @see #getFamily * @see #getName * @since 1.2 */ public String getFontName() { return getFontName(Locale.getDefault()); } /** ! * Returns the font face name of the <code>Font</code>, localized * for the specified locale. For example, Helvetica Fett could be * returned as the font face name. ! * Use <code>getFamily</code> to get the family name of the font. * @param l a locale for which to get the font face name ! * @return a <code>String</code> representing the font face name, * localized for the specified locale. * @see #getFamily * @see java.util.Locale */ public String getFontName(Locale l) { --- 1218,1274 ---- } return getFont2D().getFamilyName(l); } /** ! * Returns the postscript name of this {@code Font}. ! * Use {@code getFamily} to get the family name of the font. ! * Use {@code getFontName} to get the font face name of the font. ! * @return a {@code String} representing the postscript name of ! * this {@code Font}. * @since 1.2 */ public String getPSName() { return getFont2D().getPostscriptName(); } /** ! * Returns the logical name of this {@code Font}. ! * Use {@code getFamily} to get the family name of the font. ! * Use {@code getFontName} to get the font face name of the font. ! * @return a {@code String} representing the logical name of ! * this {@code Font}. * @see #getFamily * @see #getFontName * @since 1.0 */ public String getName() { return name; } /** ! * Returns the font face name of this {@code Font}. For example, * Helvetica Bold could be returned as a font face name. ! * Use {@code getFamily} to get the family name of the font. ! * Use {@code getName} to get the logical name of the font. ! * @return a {@code String} representing the font face name of ! * this {@code Font}. * @see #getFamily * @see #getName * @since 1.2 */ public String getFontName() { return getFontName(Locale.getDefault()); } /** ! * Returns the font face name of the {@code Font}, localized * for the specified locale. For example, Helvetica Fett could be * returned as the font face name. ! * Use {@code getFamily} to get the family name of the font. * @param l a locale for which to get the font face name ! * @return a {@code String} representing the font face name, * localized for the specified locale. * @see #getFamily * @see java.util.Locale */ public String getFontName(Locale l) {
*** 1277,1300 **** } return getFont2D().getFontName(l); } /** ! * Returns the style of this <code>Font</code>. The style can be * PLAIN, BOLD, ITALIC, or BOLD+ITALIC. ! * @return the style of this <code>Font</code> * @see #isPlain * @see #isBold * @see #isItalic * @since 1.0 */ public int getStyle() { return style; } /** ! * Returns the point size of this <code>Font</code>, rounded to * an integer. * Most users are familiar with the idea of using <i>point size</i> to * specify the size of glyphs in a font. This point size defines a * measurement between the baseline of one line to the baseline of the * following line in a single spaced text document. The point size is --- 1277,1300 ---- } return getFont2D().getFontName(l); } /** ! * Returns the style of this {@code Font}. The style can be * PLAIN, BOLD, ITALIC, or BOLD+ITALIC. ! * @return the style of this {@code Font} * @see #isPlain * @see #isBold * @see #isItalic * @since 1.0 */ public int getStyle() { return style; } /** ! * Returns the point size of this {@code Font}, rounded to * an integer. * Most users are familiar with the idea of using <i>point size</i> to * specify the size of glyphs in a font. This point size defines a * measurement between the baseline of one line to the baseline of the * following line in a single spaced text document. The point size is
*** 1304,1314 **** * equivalent to one unit in user coordinates. When using a * normalized transform for converting user space coordinates to * device space coordinates 72 user * space units equal 1 inch in device space. In this case one point * is 1/72 of an inch. ! * @return the point size of this <code>Font</code> in 1/72 of an * inch units. * @see #getSize2D * @see GraphicsConfiguration#getDefaultTransform * @see GraphicsConfiguration#getNormalizingTransform * @since 1.0 --- 1304,1314 ---- * equivalent to one unit in user coordinates. When using a * normalized transform for converting user space coordinates to * device space coordinates 72 user * space units equal 1 inch in device space. In this case one point * is 1/72 of an inch. ! * @return the point size of this {@code Font} in 1/72 of an * inch units. * @see #getSize2D * @see GraphicsConfiguration#getDefaultTransform * @see GraphicsConfiguration#getNormalizingTransform * @since 1.0
*** 1316,1382 **** public int getSize() { return size; } /** ! * Returns the point size of this <code>Font</code> in ! * <code>float</code> value. ! * @return the point size of this <code>Font</code> as a ! * <code>float</code> value. * @see #getSize * @since 1.2 */ public float getSize2D() { return pointSize; } /** ! * Indicates whether or not this <code>Font</code> object's style is * PLAIN. ! * @return <code>true</code> if this <code>Font</code> has a * PLAIN style; ! * <code>false</code> otherwise. * @see java.awt.Font#getStyle * @since 1.0 */ public boolean isPlain() { return style == 0; } /** ! * Indicates whether or not this <code>Font</code> object's style is * BOLD. ! * @return <code>true</code> if this <code>Font</code> object's * style is BOLD; ! * <code>false</code> otherwise. * @see java.awt.Font#getStyle * @since 1.0 */ public boolean isBold() { return (style & BOLD) != 0; } /** ! * Indicates whether or not this <code>Font</code> object's style is * ITALIC. ! * @return <code>true</code> if this <code>Font</code> object's * style is ITALIC; ! * <code>false</code> otherwise. * @see java.awt.Font#getStyle * @since 1.0 */ public boolean isItalic() { return (style & ITALIC) != 0; } /** ! * Indicates whether or not this <code>Font</code> object has a * transform that affects its size in addition to the Size * attribute. ! * @return <code>true</code> if this <code>Font</code> object * has a non-identity AffineTransform attribute. ! * <code>false</code> otherwise. * @see java.awt.Font#getTransform * @since 1.4 */ public boolean isTransformed() { return nonIdentityTx; --- 1316,1382 ---- public int getSize() { return size; } /** ! * Returns the point size of this {@code Font} in ! * {@code float} value. ! * @return the point size of this {@code Font} as a ! * {@code float} value. * @see #getSize * @since 1.2 */ public float getSize2D() { return pointSize; } /** ! * Indicates whether or not this {@code Font} object's style is * PLAIN. ! * @return {@code true} if this {@code Font} has a * PLAIN style; ! * {@code false} otherwise. * @see java.awt.Font#getStyle * @since 1.0 */ public boolean isPlain() { return style == 0; } /** ! * Indicates whether or not this {@code Font} object's style is * BOLD. ! * @return {@code true} if this {@code Font} object's * style is BOLD; ! * {@code false} otherwise. * @see java.awt.Font#getStyle * @since 1.0 */ public boolean isBold() { return (style & BOLD) != 0; } /** ! * Indicates whether or not this {@code Font} object's style is * ITALIC. ! * @return {@code true} if this {@code Font} object's * style is ITALIC; ! * {@code false} otherwise. * @see java.awt.Font#getStyle * @since 1.0 */ public boolean isItalic() { return (style & ITALIC) != 0; } /** ! * Indicates whether or not this {@code Font} object has a * transform that affects its size in addition to the Size * attribute. ! * @return {@code true} if this {@code Font} object * has a non-identity AffineTransform attribute. ! * {@code false} otherwise. * @see java.awt.Font#getTransform * @since 1.4 */ public boolean isTransformed() { return nonIdentityTx;
*** 1391,1424 **** public boolean hasLayoutAttributes() { return hasLayoutAttributes; } /** ! * Returns a <code>Font</code> object from the system properties list. ! * <code>nm</code> is treated as the name of a system property to be ! * obtained. The <code>String</code> value of this property is then ! * interpreted as a <code>Font</code> object according to the ! * specification of <code>Font.decode(String)</code> * If the specified property is not found, or the executing code does * not have permission to read the property, null is returned instead. * * @param nm the property name ! * @return a <code>Font</code> object that the property name * describes, or null if no such property exists. * @throws NullPointerException if nm is null. * @since 1.2 * @see #decode(String) */ public static Font getFont(String nm) { return getFont(nm, null); } /** ! * Returns the <code>Font</code> that the <code>str</code> * argument describes. * To ensure that this method returns the desired Font, ! * format the <code>str</code> parameter in * one of these ways * * <ul> * <li><em>fontname-style-pointsize</em> * <li><em>fontname-pointsize</em> --- 1391,1424 ---- public boolean hasLayoutAttributes() { return hasLayoutAttributes; } /** ! * Returns a {@code Font} object from the system properties list. ! * {@code nm} is treated as the name of a system property to be ! * obtained. The {@code String} value of this property is then ! * interpreted as a {@code Font} object according to the ! * specification of {@code Font.decode(String)} * If the specified property is not found, or the executing code does * not have permission to read the property, null is returned instead. * * @param nm the property name ! * @return a {@code Font} object that the property name * describes, or null if no such property exists. * @throws NullPointerException if nm is null. * @since 1.2 * @see #decode(String) */ public static Font getFont(String nm) { return getFont(nm, null); } /** ! * Returns the {@code Font} that the {@code str} * argument describes. * To ensure that this method returns the desired Font, ! * format the {@code str} parameter in * one of these ways * * <ul> * <li><em>fontname-style-pointsize</em> * <li><em>fontname-pointsize</em>
*** 1429,1446 **** * <li><em>fontname style</em> * <li><em>fontname</em> * </ul> * in which <i>style</i> is one of the four * case-insensitive strings: ! * <code>"PLAIN"</code>, <code>"BOLD"</code>, <code>"BOLDITALIC"</code>, or ! * <code>"ITALIC"</code>, and pointsize is a positive decimal integer * representation of the point size. * For example, if you want a font that is Arial, bold, with * a point size of 18, you would call this method with: * "Arial-BOLD-18". * This is equivalent to calling the Font constructor : ! * <code>new Font("Arial", Font.BOLD, 18);</code> * and the values are interpreted as specified by that constructor. * <p> * A valid trailing decimal field is always interpreted as the pointsize. * Therefore a fontname containing a trailing decimal value should not * be used in the fontname only form. --- 1429,1446 ---- * <li><em>fontname style</em> * <li><em>fontname</em> * </ul> * in which <i>style</i> is one of the four * case-insensitive strings: ! * {@code "PLAIN"}, {@code "BOLD"}, {@code "BOLDITALIC"}, or ! * {@code "ITALIC"}, and pointsize is a positive decimal integer * representation of the point size. * For example, if you want a font that is Arial, bold, with * a point size of 18, you would call this method with: * "Arial-BOLD-18". * This is equivalent to calling the Font constructor : ! * {@code new Font("Arial", Font.BOLD, 18);} * and the values are interpreted as specified by that constructor. * <p> * A valid trailing decimal field is always interpreted as the pointsize. * Therefore a fontname containing a trailing decimal value should not * be used in the fontname only form.
*** 1454,1489 **** * the rest of the string. * Null (empty) pointsize and style fields are treated * as valid fields with the default value for that field. *<p> * Some font names may include the separator characters ' ' or '-'. ! * If <code>str</code> is not formed with 3 components, e.g. such that ! * <code>style</code> or <code>pointsize</code> fields are not present in ! * <code>str</code>, and <code>fontname</code> also contains a * character determined to be the separator character * then these characters where they appear as intended to be part of ! * <code>fontname</code> may instead be interpreted as separators * so the font name may not be properly recognised. * * <p> * The default size is 12 and the default style is PLAIN. ! * If <code>str</code> does not specify a valid size, the returned ! * <code>Font</code> has a size of 12. If <code>str</code> does not * specify a valid style, the returned Font has a style of PLAIN. * If you do not specify a valid font name in ! * the <code>str</code> argument, this method will return * a font with the family name "Dialog". * To determine what font family names are available on * your system, use the * {@link GraphicsEnvironment#getAvailableFontFamilyNames()} method. ! * If <code>str</code> is <code>null</code>, a new <code>Font</code> * is returned with the family name "Dialog", a size of 12 and a * PLAIN style. ! * @param str the name of the font, or <code>null</code> ! * @return the <code>Font</code> object that <code>str</code> ! * describes, or a new default <code>Font</code> if ! * <code>str</code> is <code>null</code>. * @see #getFamily * @since 1.1 */ public static Font decode(String str) { String fontName = str; --- 1454,1489 ---- * the rest of the string. * Null (empty) pointsize and style fields are treated * as valid fields with the default value for that field. *<p> * Some font names may include the separator characters ' ' or '-'. ! * If {@code str} is not formed with 3 components, e.g. such that ! * {@code style} or {@code pointsize} fields are not present in ! * {@code str}, and {@code fontname} also contains a * character determined to be the separator character * then these characters where they appear as intended to be part of ! * {@code fontname} may instead be interpreted as separators * so the font name may not be properly recognised. * * <p> * The default size is 12 and the default style is PLAIN. ! * If {@code str} does not specify a valid size, the returned ! * {@code Font} has a size of 12. If {@code str} does not * specify a valid style, the returned Font has a style of PLAIN. * If you do not specify a valid font name in ! * the {@code str} argument, this method will return * a font with the family name "Dialog". * To determine what font family names are available on * your system, use the * {@link GraphicsEnvironment#getAvailableFontFamilyNames()} method. ! * If {@code str} is {@code null}, a new {@code Font} * is returned with the family name "Dialog", a size of 12 and a * PLAIN style. ! * @param str the name of the font, or {@code null} ! * @return the {@code Font} object that {@code str} ! * describes, or a new default {@code Font} if ! * {@code str} is {@code null}. * @see #getFamily * @since 1.1 */ public static Font decode(String str) { String fontName = str;
*** 1557,1582 **** return new Font(fontName, fontStyle, fontSize); } /** ! * Gets the specified <code>Font</code> from the system properties ! * list. As in the <code>getProperty</code> method of ! * <code>System</code>, the first * argument is treated as the name of a system property to be ! * obtained. The <code>String</code> value of this property is then ! * interpreted as a <code>Font</code> object. * <p> * The property value should be one of the forms accepted by ! * <code>Font.decode(String)</code> * If the specified property is not found, or the executing code does not ! * have permission to read the property, the <code>font</code> * argument is returned instead. * @param nm the case-insensitive property name ! * @param font a default <code>Font</code> to return if property ! * <code>nm</code> is not defined ! * @return the <code>Font</code> value of the property. * @throws NullPointerException if nm is null. * @see #decode(String) */ public static Font getFont(String nm, Font font) { String str = null; --- 1557,1582 ---- return new Font(fontName, fontStyle, fontSize); } /** ! * Gets the specified {@code Font} from the system properties ! * list. As in the {@code getProperty} method of ! * {@code System}, the first * argument is treated as the name of a system property to be ! * obtained. The {@code String} value of this property is then ! * interpreted as a {@code Font} object. * <p> * The property value should be one of the forms accepted by ! * {@code Font.decode(String)} * If the specified property is not found, or the executing code does not ! * have permission to read the property, the {@code font} * argument is returned instead. * @param nm the case-insensitive property name ! * @param font a default {@code Font} to return if property ! * {@code nm} is not defined ! * @return the {@code Font} value of the property. * @throws NullPointerException if nm is null. * @see #decode(String) */ public static Font getFont(String nm, Font font) { String str = null;
*** 1590,1601 **** return decode ( str ); } transient int hash; /** ! * Returns a hashcode for this <code>Font</code>. ! * @return a hashcode value for this <code>Font</code>. * @since 1.0 */ public int hashCode() { if (hash == 0) { hash = name.hashCode() ^ style ^ size; --- 1590,1601 ---- return decode ( str ); } transient int hash; /** ! * Returns a hashcode for this {@code Font}. ! * @return a hashcode value for this {@code Font}. * @since 1.0 */ public int hashCode() { if (hash == 0) { hash = name.hashCode() ^ style ^ size;
*** 1612,1628 **** } return hash; } /** ! * Compares this <code>Font</code> object to the specified ! * <code>Object</code>. ! * @param obj the <code>Object</code> to compare ! * @return <code>true</code> if the objects are the same ! * or if the argument is a <code>Font</code> object * describing the same font as this object; ! * <code>false</code> otherwise. * @since 1.0 */ public boolean equals(Object obj) { if (obj == this) { return true; --- 1612,1628 ---- } return hash; } /** ! * Compares this {@code Font} object to the specified ! * {@code Object}. ! * @param obj the {@code Object} to compare ! * @return {@code true} if the objects are the same ! * or if the argument is a {@code Font} object * describing the same font as this object; ! * {@code false} otherwise. * @since 1.0 */ public boolean equals(Object obj) { if (obj == this) { return true;
*** 1660,1673 **** } return false; } /** ! * Converts this <code>Font</code> object to a <code>String</code> * representation. ! * @return a <code>String</code> representation of this ! * <code>Font</code> object. * @since 1.0 */ // NOTE: This method may be called by privileged threads. // DO NOT INVOKE CLIENT CODE ON THIS THREAD! public String toString() { --- 1660,1673 ---- } return false; } /** ! * Converts this {@code Font} object to a {@code String} * representation. ! * @return a {@code String} representation of this ! * {@code Font} object. * @since 1.0 */ // NOTE: This method may be called by privileged threads. // DO NOT INVOKE CLIENT CODE ON THIS THREAD! public String toString() {
*** 1682,1711 **** return getClass().getName() + "[family=" + getFamily() + ",name=" + name + ",style=" + strStyle + ",size=" + size + "]"; } // toString() ! /** Serialization support. A <code>readObject</code> * method is necessary because the constructor creates * the font's peer, and we can't serialize the peer. * Similarly the computed font "family" may be different ! * at <code>readObject</code> time than at ! * <code>writeObject</code> time. An integer version is * written so that future versions of this class will be * able to recognize serialized output from this one. */ /** ! * The <code>Font</code> Serializable Data Form. * * @serial */ private int fontSerializedDataVersion = 1; /** * Writes default serializable fields to a stream. * ! * @param s the <code>ObjectOutputStream</code> to write * @see AWTEventMulticaster#save(ObjectOutputStream, String, EventListener) * @see #readObject(java.io.ObjectInputStream) */ private void writeObject(java.io.ObjectOutputStream s) throws java.lang.ClassNotFoundException, --- 1682,1711 ---- return getClass().getName() + "[family=" + getFamily() + ",name=" + name + ",style=" + strStyle + ",size=" + size + "]"; } // toString() ! /** Serialization support. A {@code readObject} * method is necessary because the constructor creates * the font's peer, and we can't serialize the peer. * Similarly the computed font "family" may be different ! * at {@code readObject} time than at ! * {@code writeObject} time. An integer version is * written so that future versions of this class will be * able to recognize serialized output from this one. */ /** ! * The {@code Font} Serializable Data Form. * * @serial */ private int fontSerializedDataVersion = 1; /** * Writes default serializable fields to a stream. * ! * @param s the {@code ObjectOutputStream} to write * @see AWTEventMulticaster#save(ObjectOutputStream, String, EventListener) * @see #readObject(java.io.ObjectInputStream) */ private void writeObject(java.io.ObjectOutputStream s) throws java.lang.ClassNotFoundException,
*** 1722,1735 **** s.defaultWriteObject(); } } /** ! * Reads the <code>ObjectInputStream</code>. * Unrecognized keys or values will be ignored. * ! * @param s the <code>ObjectInputStream</code> to read * @serial * @see #writeObject(java.io.ObjectOutputStream) */ private void readObject(java.io.ObjectInputStream s) throws java.lang.ClassNotFoundException, --- 1722,1735 ---- s.defaultWriteObject(); } } /** ! * Reads the {@code ObjectInputStream}. * Unrecognized keys or values will be ignored. * ! * @param s the {@code ObjectInputStream} to read * @serial * @see #writeObject(java.io.ObjectOutputStream) */ private void readObject(java.io.ObjectInputStream s) throws java.lang.ClassNotFoundException,
*** 1762,1785 **** fRequestedAttributes = null; // don't need it any more } } /** ! * Returns the number of glyphs in this <code>Font</code>. Glyph codes ! * for this <code>Font</code> range from 0 to ! * <code>getNumGlyphs()</code> - 1. ! * @return the number of glyphs in this <code>Font</code>. * @since 1.2 */ public int getNumGlyphs() { return getFont2D().getNumGlyphs(); } /** ! * Returns the glyphCode which is used when this <code>Font</code> * does not have a glyph for a specified unicode code point. ! * @return the glyphCode of this <code>Font</code>. * @since 1.2 */ public int getMissingGlyphCode() { return getFont2D().getMissingGlyphCode(); } --- 1762,1785 ---- fRequestedAttributes = null; // don't need it any more } } /** ! * Returns the number of glyphs in this {@code Font}. Glyph codes ! * for this {@code Font} range from 0 to ! * {@code getNumGlyphs()} - 1. ! * @return the number of glyphs in this {@code Font}. * @since 1.2 */ public int getNumGlyphs() { return getFont2D().getNumGlyphs(); } /** ! * Returns the glyphCode which is used when this {@code Font} * does not have a glyph for a specified unicode code point. ! * @return the glyphCode of this {@code Font}. * @since 1.2 */ public int getMissingGlyphCode() { return getFont2D().getMissingGlyphCode(); }
*** 1804,1827 **** return getFont2D().getBaselineFor(c); } /** * Returns a map of font attributes available in this ! * <code>Font</code>. Attributes include things like ligatures and * glyph substitution. ! * @return the attributes map of this <code>Font</code>. */ public Map<TextAttribute,?> getAttributes(){ return new AttributeMap(getAttributeValues()); } /** * Returns the keys of all the attributes supported by this ! * <code>Font</code>. These attributes can be used to derive other * fonts. * @return an array containing the keys of all the attributes ! * supported by this <code>Font</code>. * @since 1.2 */ public Attribute[] getAvailableAttributes() { // FONT is not supported by Font --- 1804,1827 ---- return getFont2D().getBaselineFor(c); } /** * Returns a map of font attributes available in this ! * {@code Font}. Attributes include things like ligatures and * glyph substitution. ! * @return the attributes map of this {@code Font}. */ public Map<TextAttribute,?> getAttributes(){ return new AttributeMap(getAttributeValues()); } /** * Returns the keys of all the attributes supported by this ! * {@code Font}. These attributes can be used to derive other * fonts. * @return an array containing the keys of all the attributes ! * supported by this {@code Font}. * @since 1.2 */ public Attribute[] getAvailableAttributes() { // FONT is not supported by Font
*** 1852,1866 **** return attributes; } /** ! * Creates a new <code>Font</code> object by replicating this ! * <code>Font</code> object and applying a new style and size. ! * @param style the style for the new <code>Font</code> ! * @param size the size for the new <code>Font</code> ! * @return a new <code>Font</code> object. * @since 1.2 */ public Font deriveFont(int style, float size){ if (values == null) { return new Font(name, style, size, createdFont, font2DHandle); --- 1852,1866 ---- return attributes; } /** ! * Creates a new {@code Font} object by replicating this ! * {@code Font} object and applying a new style and size. ! * @param style the style for the new {@code Font} ! * @param size the size for the new {@code Font} ! * @return a new {@code Font} object. * @since 1.2 */ public Font deriveFont(int style, float size){ if (values == null) { return new Font(name, style, size, createdFont, font2DHandle);
*** 1871,1888 **** newValues.setSize(size); return new Font(newValues, null, oldStyle, createdFont, font2DHandle); } /** ! * Creates a new <code>Font</code> object by replicating this ! * <code>Font</code> object and applying a new style and transform. ! * @param style the style for the new <code>Font</code> ! * @param trans the <code>AffineTransform</code> associated with the ! * new <code>Font</code> ! * @return a new <code>Font</code> object. ! * @throws IllegalArgumentException if <code>trans</code> is ! * <code>null</code> * @since 1.2 */ public Font deriveFont(int style, AffineTransform trans){ AttributeValues newValues = getAttributeValues().clone(); int oldStyle = (this.style != style) ? this.style : -1; --- 1871,1888 ---- newValues.setSize(size); return new Font(newValues, null, oldStyle, createdFont, font2DHandle); } /** ! * Creates a new {@code Font} object by replicating this ! * {@code Font} object and applying a new style and transform. ! * @param style the style for the new {@code Font} ! * @param trans the {@code AffineTransform} associated with the ! * new {@code Font} ! * @return a new {@code Font} object. ! * @throws IllegalArgumentException if {@code trans} is ! * {@code null} * @since 1.2 */ public Font deriveFont(int style, AffineTransform trans){ AttributeValues newValues = getAttributeValues().clone(); int oldStyle = (this.style != style) ? this.style : -1;
*** 1890,1903 **** applyTransform(trans, newValues); return new Font(newValues, null, oldStyle, createdFont, font2DHandle); } /** ! * Creates a new <code>Font</code> object by replicating the current ! * <code>Font</code> object and applying a new size to it. ! * @param size the size for the new <code>Font</code>. ! * @return a new <code>Font</code> object. * @since 1.2 */ public Font deriveFont(float size){ if (values == null) { return new Font(name, style, size, createdFont, font2DHandle); --- 1890,1903 ---- applyTransform(trans, newValues); return new Font(newValues, null, oldStyle, createdFont, font2DHandle); } /** ! * Creates a new {@code Font} object by replicating the current ! * {@code Font} object and applying a new size to it. ! * @param size the size for the new {@code Font}. ! * @return a new {@code Font} object. * @since 1.2 */ public Font deriveFont(float size){ if (values == null) { return new Font(name, style, size, createdFont, font2DHandle);
*** 1906,1935 **** newValues.setSize(size); return new Font(newValues, null, -1, createdFont, font2DHandle); } /** ! * Creates a new <code>Font</code> object by replicating the current ! * <code>Font</code> object and applying a new transform to it. ! * @param trans the <code>AffineTransform</code> associated with the ! * new <code>Font</code> ! * @return a new <code>Font</code> object. ! * @throws IllegalArgumentException if <code>trans</code> is ! * <code>null</code> * @since 1.2 */ public Font deriveFont(AffineTransform trans){ AttributeValues newValues = getAttributeValues().clone(); applyTransform(trans, newValues); return new Font(newValues, null, -1, createdFont, font2DHandle); } /** ! * Creates a new <code>Font</code> object by replicating the current ! * <code>Font</code> object and applying a new style to it. ! * @param style the style for the new <code>Font</code> ! * @return a new <code>Font</code> object. * @since 1.2 */ public Font deriveFont(int style){ if (values == null) { return new Font(name, style, size, createdFont, font2DHandle); --- 1906,1935 ---- newValues.setSize(size); return new Font(newValues, null, -1, createdFont, font2DHandle); } /** ! * Creates a new {@code Font} object by replicating the current ! * {@code Font} object and applying a new transform to it. ! * @param trans the {@code AffineTransform} associated with the ! * new {@code Font} ! * @return a new {@code Font} object. ! * @throws IllegalArgumentException if {@code trans} is ! * {@code null} * @since 1.2 */ public Font deriveFont(AffineTransform trans){ AttributeValues newValues = getAttributeValues().clone(); applyTransform(trans, newValues); return new Font(newValues, null, -1, createdFont, font2DHandle); } /** ! * Creates a new {@code Font} object by replicating the current ! * {@code Font} object and applying a new style to it. ! * @param style the style for the new {@code Font} ! * @return a new {@code Font} object. * @since 1.2 */ public Font deriveFont(int style){ if (values == null) { return new Font(name, style, size, createdFont, font2DHandle);
*** 1939,1955 **** applyStyle(style, newValues); return new Font(newValues, null, oldStyle, createdFont, font2DHandle); } /** ! * Creates a new <code>Font</code> object by replicating the current ! * <code>Font</code> object and applying a new set of font attributes * to it. * * @param attributes a map of attributes enabled for the new ! * <code>Font</code> ! * @return a new <code>Font</code> object. * @since 1.2 */ public Font deriveFont(Map<? extends Attribute, ?> attributes) { if (attributes == null) { return this; --- 1939,1955 ---- applyStyle(style, newValues); return new Font(newValues, null, oldStyle, createdFont, font2DHandle); } /** ! * Creates a new {@code Font} object by replicating the current ! * {@code Font} object and applying a new set of font attributes * to it. * * @param attributes a map of attributes enabled for the new ! * {@code Font} ! * @return a new {@code Font} object. * @since 1.2 */ public Font deriveFont(Map<? extends Attribute, ?> attributes) { if (attributes == null) { return this;
*** 1959,1994 **** return new Font(newValues, name, style, createdFont, font2DHandle); } /** ! * Checks if this <code>Font</code> has a glyph for the specified * character. * * <p> <b>Note:</b> This method cannot handle <a * href="../../java/lang/Character.html#supplementary"> supplementary * characters</a>. To support all Unicode characters, including * supplementary characters, use the {@link #canDisplay(int)} ! * method or <code>canDisplayUpTo</code> methods. * * @param c the character for which a glyph is needed ! * @return <code>true</code> if this <code>Font</code> has a glyph for this ! * character; <code>false</code> otherwise. * @since 1.2 */ public boolean canDisplay(char c){ return getFont2D().canDisplay(c); } /** ! * Checks if this <code>Font</code> has a glyph for the specified * character. * * @param codePoint the character (Unicode code point) for which a glyph * is needed. ! * @return <code>true</code> if this <code>Font</code> has a glyph for the ! * character; <code>false</code> otherwise. * @throws IllegalArgumentException if the code point is not a valid Unicode * code point. * @see Character#isValidCodePoint(int) * @since 1.5 */ --- 1959,1994 ---- return new Font(newValues, name, style, createdFont, font2DHandle); } /** ! * Checks if this {@code Font} has a glyph for the specified * character. * * <p> <b>Note:</b> This method cannot handle <a * href="../../java/lang/Character.html#supplementary"> supplementary * characters</a>. To support all Unicode characters, including * supplementary characters, use the {@link #canDisplay(int)} ! * method or {@code canDisplayUpTo} methods. * * @param c the character for which a glyph is needed ! * @return {@code true} if this {@code Font} has a glyph for this ! * character; {@code false} otherwise. * @since 1.2 */ public boolean canDisplay(char c){ return getFont2D().canDisplay(c); } /** ! * Checks if this {@code Font} has a glyph for the specified * character. * * @param codePoint the character (Unicode code point) for which a glyph * is needed. ! * @return {@code true} if this {@code Font} has a glyph for the ! * character; {@code false} otherwise. * @throws IllegalArgumentException if the code point is not a valid Unicode * code point. * @see Character#isValidCodePoint(int) * @since 1.5 */
*** 1999,2022 **** } return getFont2D().canDisplay(codePoint); } /** ! * Indicates whether or not this <code>Font</code> can display a ! * specified <code>String</code>. For strings with Unicode encoding, * it is important to know if a particular font can display the ! * string. This method returns an offset into the <code>String</code> ! * <code>str</code> which is the first character this ! * <code>Font</code> cannot display without using the missing glyph ! * code. If the <code>Font</code> can display all characters, -1 is * returned. ! * @param str a <code>String</code> object ! * @return an offset into <code>str</code> that points ! * to the first character in <code>str</code> that this ! * <code>Font</code> cannot display; or <code>-1</code> if ! * this <code>Font</code> can display all characters in ! * <code>str</code>. * @since 1.2 */ public int canDisplayUpTo(String str) { Font2D font2d = getFont2D(); int len = str.length(); --- 1999,2022 ---- } return getFont2D().canDisplay(codePoint); } /** ! * Indicates whether or not this {@code Font} can display a ! * specified {@code String}. For strings with Unicode encoding, * it is important to know if a particular font can display the ! * string. This method returns an offset into the {@code String} ! * {@code str} which is the first character this ! * {@code Font} cannot display without using the missing glyph ! * code. If the {@code Font} can display all characters, -1 is * returned. ! * @param str a {@code String} object ! * @return an offset into {@code str} that points ! * to the first character in {@code str} that this ! * {@code Font} cannot display; or {@code -1} if ! * this {@code Font} can display all characters in ! * {@code str}. * @since 1.2 */ public int canDisplayUpTo(String str) { Font2D font2d = getFont2D(); int len = str.length();
*** 2035,2060 **** } return -1; } /** ! * Indicates whether or not this <code>Font</code> can display ! * the characters in the specified <code>text</code> ! * starting at <code>start</code> and ending at ! * <code>limit</code>. This method is a convenience overload. ! * @param text the specified array of <code>char</code> values * @param start the specified starting offset (in ! * <code>char</code>s) into the specified array of ! * <code>char</code> values * @param limit the specified ending offset (in ! * <code>char</code>s) into the specified array of ! * <code>char</code> values ! * @return an offset into <code>text</code> that points ! * to the first character in <code>text</code> that this ! * <code>Font</code> cannot display; or <code>-1</code> if ! * this <code>Font</code> can display all characters in ! * <code>text</code>. * @since 1.2 */ public int canDisplayUpTo(char[] text, int start, int limit) { Font2D font2d = getFont2D(); for (int i = start; i < limit; i++) { --- 2035,2060 ---- } return -1; } /** ! * Indicates whether or not this {@code Font} can display ! * the characters in the specified {@code text} ! * starting at {@code start} and ending at ! * {@code limit}. This method is a convenience overload. ! * @param text the specified array of {@code char} values * @param start the specified starting offset (in ! * {@code char}s) into the specified array of ! * {@code char} values * @param limit the specified ending offset (in ! * {@code char}s) into the specified array of ! * {@code char} values ! * @return an offset into {@code text} that points ! * to the first character in {@code text} that this ! * {@code Font} cannot display; or {@code -1} if ! * this {@code Font} can display all characters in ! * {@code text}. * @since 1.2 */ public int canDisplayUpTo(char[] text, int start, int limit) { Font2D font2d = getFont2D(); for (int i = start; i < limit; i++) {
*** 2072,2095 **** } return -1; } /** ! * Indicates whether or not this <code>Font</code> can display the ! * text specified by the <code>iter</code> starting at ! * <code>start</code> and ending at <code>limit</code>. * * @param iter a {@link CharacterIterator} object * @param start the specified starting offset into the specified ! * <code>CharacterIterator</code>. * @param limit the specified ending offset into the specified ! * <code>CharacterIterator</code>. ! * @return an offset into <code>iter</code> that points ! * to the first character in <code>iter</code> that this ! * <code>Font</code> cannot display; or <code>-1</code> if ! * this <code>Font</code> can display all characters in ! * <code>iter</code>. * @since 1.2 */ public int canDisplayUpTo(CharacterIterator iter, int start, int limit) { Font2D font2d = getFont2D(); char c = iter.setIndex(start); --- 2072,2095 ---- } return -1; } /** ! * Indicates whether or not this {@code Font} can display the ! * text specified by the {@code iter} starting at ! * {@code start} and ending at {@code limit}. * * @param iter a {@link CharacterIterator} object * @param start the specified starting offset into the specified ! * {@code CharacterIterator}. * @param limit the specified ending offset into the specified ! * {@code CharacterIterator}. ! * @return an offset into {@code iter} that points ! * to the first character in {@code iter} that this ! * {@code Font} cannot display; or {@code -1} if ! * this {@code Font} can display all characters in ! * {@code iter}. * @since 1.2 */ public int canDisplayUpTo(CharacterIterator iter, int start, int limit) { Font2D font2d = getFont2D(); char c = iter.setIndex(start);
*** 2112,2126 **** } return -1; } /** ! * Returns the italic angle of this <code>Font</code>. The italic angle * is the inverse slope of the caret which best matches the posture of this ! * <code>Font</code>. * @see TextAttribute#POSTURE ! * @return the angle of the ITALIC style of this <code>Font</code>. */ public float getItalicAngle() { return getItalicAngle(null); } --- 2112,2126 ---- } return -1; } /** ! * Returns the italic angle of this {@code Font}. The italic angle * is the inverse slope of the caret which best matches the posture of this ! * {@code Font}. * @see TextAttribute#POSTURE ! * @return the angle of the ITALIC style of this {@code Font}. */ public float getItalicAngle() { return getItalicAngle(null); }
*** 2143,2161 **** } return getFont2D().getItalicAngle(this, identityTx, aa, fm); } /** ! * Checks whether or not this <code>Font</code> has uniform ! * line metrics. A logical <code>Font</code> might be a * composite font, which means that it is composed of different * physical fonts to cover different code ranges. Each of these ! * fonts might have different <code>LineMetrics</code>. If the ! * logical <code>Font</code> is a single * font then the metrics would be uniform. ! * @return <code>true</code> if this <code>Font</code> has ! * uniform line metrics; <code>false</code> otherwise. */ public boolean hasUniformLineMetrics() { return false; // REMIND always safe, but prevents caller optimize } --- 2143,2161 ---- } return getFont2D().getItalicAngle(this, identityTx, aa, fm); } /** ! * Checks whether or not this {@code Font} has uniform ! * line metrics. A logical {@code Font} might be a * composite font, which means that it is composed of different * physical fonts to cover different code ranges. Each of these ! * fonts might have different {@code LineMetrics}. If the ! * logical {@code Font} is a single * font then the metrics would be uniform. ! * @return {@code true} if this {@code Font} has ! * uniform line metrics; {@code false} otherwise. */ public boolean hasUniformLineMetrics() { return false; // REMIND always safe, but prevents caller optimize }
*** 2233,2262 **** return (FontLineMetrics)flm.clone(); } /** * Returns a {@link LineMetrics} object created with the specified ! * <code>String</code> and {@link FontRenderContext}. ! * @param str the specified <code>String</code> ! * @param frc the specified <code>FontRenderContext</code> ! * @return a <code>LineMetrics</code> object created with the ! * specified <code>String</code> and {@link FontRenderContext}. */ public LineMetrics getLineMetrics( String str, FontRenderContext frc) { FontLineMetrics flm = defaultLineMetrics(frc); flm.numchars = str.length(); return flm; } /** ! * Returns a <code>LineMetrics</code> object created with the * specified arguments. ! * @param str the specified <code>String</code> ! * @param beginIndex the initial offset of <code>str</code> ! * @param limit the end offset of <code>str</code> ! * @param frc the specified <code>FontRenderContext</code> ! * @return a <code>LineMetrics</code> object created with the * specified arguments. */ public LineMetrics getLineMetrics( String str, int beginIndex, int limit, FontRenderContext frc) { --- 2233,2262 ---- return (FontLineMetrics)flm.clone(); } /** * Returns a {@link LineMetrics} object created with the specified ! * {@code String} and {@link FontRenderContext}. ! * @param str the specified {@code String} ! * @param frc the specified {@code FontRenderContext} ! * @return a {@code LineMetrics} object created with the ! * specified {@code String} and {@link FontRenderContext}. */ public LineMetrics getLineMetrics( String str, FontRenderContext frc) { FontLineMetrics flm = defaultLineMetrics(frc); flm.numchars = str.length(); return flm; } /** ! * Returns a {@code LineMetrics} object created with the * specified arguments. ! * @param str the specified {@code String} ! * @param beginIndex the initial offset of {@code str} ! * @param limit the end offset of {@code str} ! * @param frc the specified {@code FontRenderContext} ! * @return a {@code LineMetrics} object created with the * specified arguments. */ public LineMetrics getLineMetrics( String str, int beginIndex, int limit, FontRenderContext frc) {
*** 2265,2281 **** flm.numchars = (numChars < 0)? 0: numChars; return flm; } /** ! * Returns a <code>LineMetrics</code> object created with the * specified arguments. * @param chars an array of characters ! * @param beginIndex the initial offset of <code>chars</code> ! * @param limit the end offset of <code>chars</code> ! * @param frc the specified <code>FontRenderContext</code> ! * @return a <code>LineMetrics</code> object created with the * specified arguments. */ public LineMetrics getLineMetrics(char [] chars, int beginIndex, int limit, FontRenderContext frc) { --- 2265,2281 ---- flm.numchars = (numChars < 0)? 0: numChars; return flm; } /** ! * Returns a {@code LineMetrics} object created with the * specified arguments. * @param chars an array of characters ! * @param beginIndex the initial offset of {@code chars} ! * @param limit the end offset of {@code chars} ! * @param frc the specified {@code FontRenderContext} ! * @return a {@code LineMetrics} object created with the * specified arguments. */ public LineMetrics getLineMetrics(char [] chars, int beginIndex, int limit, FontRenderContext frc) {
*** 2284,2300 **** flm.numchars = (numChars < 0)? 0: numChars; return flm; } /** ! * Returns a <code>LineMetrics</code> object created with the * specified arguments. ! * @param ci the specified <code>CharacterIterator</code> ! * @param beginIndex the initial offset in <code>ci</code> ! * @param limit the end offset of <code>ci</code> ! * @param frc the specified <code>FontRenderContext</code> ! * @return a <code>LineMetrics</code> object created with the * specified arguments. */ public LineMetrics getLineMetrics(CharacterIterator ci, int beginIndex, int limit, FontRenderContext frc) { --- 2284,2300 ---- flm.numchars = (numChars < 0)? 0: numChars; return flm; } /** ! * Returns a {@code LineMetrics} object created with the * specified arguments. ! * @param ci the specified {@code CharacterIterator} ! * @param beginIndex the initial offset in {@code ci} ! * @param limit the end offset of {@code ci} ! * @param frc the specified {@code FontRenderContext} ! * @return a {@code LineMetrics} object created with the * specified arguments. */ public LineMetrics getLineMetrics(CharacterIterator ci, int beginIndex, int limit, FontRenderContext frc) {
*** 2303,2360 **** flm.numchars = (numChars < 0)? 0: numChars; return flm; } /** ! * Returns the logical bounds of the specified <code>String</code> in ! * the specified <code>FontRenderContext</code>. The logical bounds * contains the origin, ascent, advance, and height, which includes * the leading. The logical bounds does not always enclose all the * text. For example, in some languages and in some fonts, accent * marks can be positioned above the ascent or below the descent. * To obtain a visual bounding box, which encloses all the text, * use the {@link TextLayout#getBounds() getBounds} method of ! * <code>TextLayout</code>. * <p>Note: The returned bounds is in baseline-relative coordinates * (see {@link java.awt.Font class notes}). ! * @param str the specified <code>String</code> ! * @param frc the specified <code>FontRenderContext</code> * @return a {@link Rectangle2D} that is the bounding box of the ! * specified <code>String</code> in the specified ! * <code>FontRenderContext</code>. * @see FontRenderContext * @see Font#createGlyphVector * @since 1.2 */ public Rectangle2D getStringBounds( String str, FontRenderContext frc) { char[] array = str.toCharArray(); return getStringBounds(array, 0, array.length, frc); } /** ! * Returns the logical bounds of the specified <code>String</code> in ! * the specified <code>FontRenderContext</code>. The logical bounds * contains the origin, ascent, advance, and height, which includes * the leading. The logical bounds does not always enclose all the * text. For example, in some languages and in some fonts, accent * marks can be positioned above the ascent or below the descent. * To obtain a visual bounding box, which encloses all the text, * use the {@link TextLayout#getBounds() getBounds} method of ! * <code>TextLayout</code>. * <p>Note: The returned bounds is in baseline-relative coordinates * (see {@link java.awt.Font class notes}). ! * @param str the specified <code>String</code> ! * @param beginIndex the initial offset of <code>str</code> ! * @param limit the end offset of <code>str</code> ! * @param frc the specified <code>FontRenderContext</code> ! * @return a <code>Rectangle2D</code> that is the bounding box of the ! * specified <code>String</code> in the specified ! * <code>FontRenderContext</code>. ! * @throws IndexOutOfBoundsException if <code>beginIndex</code> is ! * less than zero, or <code>limit</code> is greater than the ! * length of <code>str</code>, or <code>beginIndex</code> ! * is greater than <code>limit</code>. * @see FontRenderContext * @see Font#createGlyphVector * @since 1.2 */ public Rectangle2D getStringBounds( String str, --- 2303,2360 ---- flm.numchars = (numChars < 0)? 0: numChars; return flm; } /** ! * Returns the logical bounds of the specified {@code String} in ! * the specified {@code FontRenderContext}. The logical bounds * contains the origin, ascent, advance, and height, which includes * the leading. The logical bounds does not always enclose all the * text. For example, in some languages and in some fonts, accent * marks can be positioned above the ascent or below the descent. * To obtain a visual bounding box, which encloses all the text, * use the {@link TextLayout#getBounds() getBounds} method of ! * {@code TextLayout}. * <p>Note: The returned bounds is in baseline-relative coordinates * (see {@link java.awt.Font class notes}). ! * @param str the specified {@code String} ! * @param frc the specified {@code FontRenderContext} * @return a {@link Rectangle2D} that is the bounding box of the ! * specified {@code String} in the specified ! * {@code FontRenderContext}. * @see FontRenderContext * @see Font#createGlyphVector * @since 1.2 */ public Rectangle2D getStringBounds( String str, FontRenderContext frc) { char[] array = str.toCharArray(); return getStringBounds(array, 0, array.length, frc); } /** ! * Returns the logical bounds of the specified {@code String} in ! * the specified {@code FontRenderContext}. The logical bounds * contains the origin, ascent, advance, and height, which includes * the leading. The logical bounds does not always enclose all the * text. For example, in some languages and in some fonts, accent * marks can be positioned above the ascent or below the descent. * To obtain a visual bounding box, which encloses all the text, * use the {@link TextLayout#getBounds() getBounds} method of ! * {@code TextLayout}. * <p>Note: The returned bounds is in baseline-relative coordinates * (see {@link java.awt.Font class notes}). ! * @param str the specified {@code String} ! * @param beginIndex the initial offset of {@code str} ! * @param limit the end offset of {@code str} ! * @param frc the specified {@code FontRenderContext} ! * @return a {@code Rectangle2D} that is the bounding box of the ! * specified {@code String} in the specified ! * {@code FontRenderContext}. ! * @throws IndexOutOfBoundsException if {@code beginIndex} is ! * less than zero, or {@code limit} is greater than the ! * length of {@code str}, or {@code beginIndex} ! * is greater than {@code limit}. * @see FontRenderContext * @see Font#createGlyphVector * @since 1.2 */ public Rectangle2D getStringBounds( String str,
*** 2364,2395 **** return getStringBounds(substr, frc); } /** * Returns the logical bounds of the specified array of characters ! * in the specified <code>FontRenderContext</code>. The logical * bounds contains the origin, ascent, advance, and height, which * includes the leading. The logical bounds does not always enclose * all the text. For example, in some languages and in some fonts, * accent marks can be positioned above the ascent or below the * descent. To obtain a visual bounding box, which encloses all the * text, use the {@link TextLayout#getBounds() getBounds} method of ! * <code>TextLayout</code>. * <p>Note: The returned bounds is in baseline-relative coordinates * (see {@link java.awt.Font class notes}). * @param chars an array of characters * @param beginIndex the initial offset in the array of * characters * @param limit the end offset in the array of characters ! * @param frc the specified <code>FontRenderContext</code> ! * @return a <code>Rectangle2D</code> that is the bounding box of the * specified array of characters in the specified ! * <code>FontRenderContext</code>. ! * @throws IndexOutOfBoundsException if <code>beginIndex</code> is ! * less than zero, or <code>limit</code> is greater than the ! * length of <code>chars</code>, or <code>beginIndex</code> ! * is greater than <code>limit</code>. * @see FontRenderContext * @see Font#createGlyphVector * @since 1.2 */ public Rectangle2D getStringBounds(char [] chars, --- 2364,2395 ---- return getStringBounds(substr, frc); } /** * Returns the logical bounds of the specified array of characters ! * in the specified {@code FontRenderContext}. The logical * bounds contains the origin, ascent, advance, and height, which * includes the leading. The logical bounds does not always enclose * all the text. For example, in some languages and in some fonts, * accent marks can be positioned above the ascent or below the * descent. To obtain a visual bounding box, which encloses all the * text, use the {@link TextLayout#getBounds() getBounds} method of ! * {@code TextLayout}. * <p>Note: The returned bounds is in baseline-relative coordinates * (see {@link java.awt.Font class notes}). * @param chars an array of characters * @param beginIndex the initial offset in the array of * characters * @param limit the end offset in the array of characters ! * @param frc the specified {@code FontRenderContext} ! * @return a {@code Rectangle2D} that is the bounding box of the * specified array of characters in the specified ! * {@code FontRenderContext}. ! * @throws IndexOutOfBoundsException if {@code beginIndex} is ! * less than zero, or {@code limit} is greater than the ! * length of {@code chars}, or {@code beginIndex} ! * is greater than {@code limit}. * @see FontRenderContext * @see Font#createGlyphVector * @since 1.2 */ public Rectangle2D getStringBounds(char [] chars,
*** 2431,2465 **** } /** * Returns the logical bounds of the characters indexed in the * specified {@link CharacterIterator} in the ! * specified <code>FontRenderContext</code>. The logical bounds * contains the origin, ascent, advance, and height, which includes * the leading. The logical bounds does not always enclose all the * text. For example, in some languages and in some fonts, accent * marks can be positioned above the ascent or below the descent. * To obtain a visual bounding box, which encloses all the text, * use the {@link TextLayout#getBounds() getBounds} method of ! * <code>TextLayout</code>. * <p>Note: The returned bounds is in baseline-relative coordinates * (see {@link java.awt.Font class notes}). ! * @param ci the specified <code>CharacterIterator</code> ! * @param beginIndex the initial offset in <code>ci</code> ! * @param limit the end offset in <code>ci</code> ! * @param frc the specified <code>FontRenderContext</code> ! * @return a <code>Rectangle2D</code> that is the bounding box of the ! * characters indexed in the specified <code>CharacterIterator</code> ! * in the specified <code>FontRenderContext</code>. * @see FontRenderContext * @see Font#createGlyphVector * @since 1.2 ! * @throws IndexOutOfBoundsException if <code>beginIndex</code> is ! * less than the start index of <code>ci</code>, or ! * <code>limit</code> is greater than the end index of ! * <code>ci</code>, or <code>beginIndex</code> is greater ! * than <code>limit</code> */ public Rectangle2D getStringBounds(CharacterIterator ci, int beginIndex, int limit, FontRenderContext frc) { int start = ci.getBeginIndex(); --- 2431,2465 ---- } /** * Returns the logical bounds of the characters indexed in the * specified {@link CharacterIterator} in the ! * specified {@code FontRenderContext}. The logical bounds * contains the origin, ascent, advance, and height, which includes * the leading. The logical bounds does not always enclose all the * text. For example, in some languages and in some fonts, accent * marks can be positioned above the ascent or below the descent. * To obtain a visual bounding box, which encloses all the text, * use the {@link TextLayout#getBounds() getBounds} method of ! * {@code TextLayout}. * <p>Note: The returned bounds is in baseline-relative coordinates * (see {@link java.awt.Font class notes}). ! * @param ci the specified {@code CharacterIterator} ! * @param beginIndex the initial offset in {@code ci} ! * @param limit the end offset in {@code ci} ! * @param frc the specified {@code FontRenderContext} ! * @return a {@code Rectangle2D} that is the bounding box of the ! * characters indexed in the specified {@code CharacterIterator} ! * in the specified {@code FontRenderContext}. * @see FontRenderContext * @see Font#createGlyphVector * @since 1.2 ! * @throws IndexOutOfBoundsException if {@code beginIndex} is ! * less than the start index of {@code ci}, or ! * {@code limit} is greater than the end index of ! * {@code ci}, or {@code beginIndex} is greater ! * than {@code limit} */ public Rectangle2D getStringBounds(CharacterIterator ci, int beginIndex, int limit, FontRenderContext frc) { int start = ci.getBeginIndex();
*** 2487,2501 **** return getStringBounds(arr,0,arr.length,frc); } /** * Returns the bounds for the character with the maximum ! * bounds as defined in the specified <code>FontRenderContext</code>. * <p>Note: The returned bounds is in baseline-relative coordinates * (see {@link java.awt.Font class notes}). ! * @param frc the specified <code>FontRenderContext</code> ! * @return a <code>Rectangle2D</code> that is the bounding box * for the character with the maximum bounds. */ public Rectangle2D getMaxCharBounds(FontRenderContext frc) { float [] metrics = new float[4]; --- 2487,2501 ---- return getStringBounds(arr,0,arr.length,frc); } /** * Returns the bounds for the character with the maximum ! * bounds as defined in the specified {@code FontRenderContext}. * <p>Note: The returned bounds is in baseline-relative coordinates * (see {@link java.awt.Font class notes}). ! * @param frc the specified {@code FontRenderContext} ! * @return a {@code Rectangle2D} that is the bounding box * for the character with the maximum bounds. */ public Rectangle2D getMaxCharBounds(FontRenderContext frc) { float [] metrics = new float[4];
*** 2507,2599 **** } /** * Creates a {@link java.awt.font.GlyphVector GlyphVector} by * mapping characters to glyphs one-to-one based on the ! * Unicode cmap in this <code>Font</code>. This method does no other * processing besides the mapping of glyphs to characters. This * means that this method is not useful for some scripts, such * as Arabic, Hebrew, Thai, and Indic, that require reordering, * shaping, or ligature substitution. ! * @param frc the specified <code>FontRenderContext</code> ! * @param str the specified <code>String</code> ! * @return a new <code>GlyphVector</code> created with the ! * specified <code>String</code> and the specified ! * <code>FontRenderContext</code>. */ public GlyphVector createGlyphVector(FontRenderContext frc, String str) { return (GlyphVector)new StandardGlyphVector(this, str, frc); } /** * Creates a {@link java.awt.font.GlyphVector GlyphVector} by * mapping characters to glyphs one-to-one based on the ! * Unicode cmap in this <code>Font</code>. This method does no other * processing besides the mapping of glyphs to characters. This * means that this method is not useful for some scripts, such * as Arabic, Hebrew, Thai, and Indic, that require reordering, * shaping, or ligature substitution. ! * @param frc the specified <code>FontRenderContext</code> * @param chars the specified array of characters ! * @return a new <code>GlyphVector</code> created with the * specified array of characters and the specified ! * <code>FontRenderContext</code>. */ public GlyphVector createGlyphVector(FontRenderContext frc, char[] chars) { return (GlyphVector)new StandardGlyphVector(this, chars, frc); } /** * Creates a {@link java.awt.font.GlyphVector GlyphVector} by * mapping the specified characters to glyphs one-to-one based on the ! * Unicode cmap in this <code>Font</code>. This method does no other * processing besides the mapping of glyphs to characters. This * means that this method is not useful for some scripts, such * as Arabic, Hebrew, Thai, and Indic, that require reordering, * shaping, or ligature substitution. ! * @param frc the specified <code>FontRenderContext</code> ! * @param ci the specified <code>CharacterIterator</code> ! * @return a new <code>GlyphVector</code> created with the ! * specified <code>CharacterIterator</code> and the specified ! * <code>FontRenderContext</code>. */ public GlyphVector createGlyphVector( FontRenderContext frc, CharacterIterator ci) { return (GlyphVector)new StandardGlyphVector(this, ci, frc); } /** * Creates a {@link java.awt.font.GlyphVector GlyphVector} by * mapping characters to glyphs one-to-one based on the ! * Unicode cmap in this <code>Font</code>. This method does no other * processing besides the mapping of glyphs to characters. This * means that this method is not useful for some scripts, such * as Arabic, Hebrew, Thai, and Indic, that require reordering, * shaping, or ligature substitution. ! * @param frc the specified <code>FontRenderContext</code> * @param glyphCodes the specified integer array ! * @return a new <code>GlyphVector</code> created with the * specified integer array and the specified ! * <code>FontRenderContext</code>. */ public GlyphVector createGlyphVector( FontRenderContext frc, int [] glyphCodes) { return (GlyphVector)new StandardGlyphVector(this, glyphCodes, frc); } /** ! * Returns a new <code>GlyphVector</code> object, performing full * layout of the text if possible. Full layout is required for * complex text, such as Arabic or Hindi. Support for different * scripts depends on the font and implementation. * <p> * Layout requires bidi analysis, as performed by ! * <code>Bidi</code>, and should only be performed on text that * has a uniform direction. The direction is indicated in the * flags parameter,by using LAYOUT_RIGHT_TO_LEFT to indicate a * right-to-left (Arabic and Hebrew) run direction, or * LAYOUT_LEFT_TO_RIGHT to indicate a left-to-right (English) * run direction. --- 2507,2599 ---- } /** * Creates a {@link java.awt.font.GlyphVector GlyphVector} by * mapping characters to glyphs one-to-one based on the ! * Unicode cmap in this {@code Font}. This method does no other * processing besides the mapping of glyphs to characters. This * means that this method is not useful for some scripts, such * as Arabic, Hebrew, Thai, and Indic, that require reordering, * shaping, or ligature substitution. ! * @param frc the specified {@code FontRenderContext} ! * @param str the specified {@code String} ! * @return a new {@code GlyphVector} created with the ! * specified {@code String} and the specified ! * {@code FontRenderContext}. */ public GlyphVector createGlyphVector(FontRenderContext frc, String str) { return (GlyphVector)new StandardGlyphVector(this, str, frc); } /** * Creates a {@link java.awt.font.GlyphVector GlyphVector} by * mapping characters to glyphs one-to-one based on the ! * Unicode cmap in this {@code Font}. This method does no other * processing besides the mapping of glyphs to characters. This * means that this method is not useful for some scripts, such * as Arabic, Hebrew, Thai, and Indic, that require reordering, * shaping, or ligature substitution. ! * @param frc the specified {@code FontRenderContext} * @param chars the specified array of characters ! * @return a new {@code GlyphVector} created with the * specified array of characters and the specified ! * {@code FontRenderContext}. */ public GlyphVector createGlyphVector(FontRenderContext frc, char[] chars) { return (GlyphVector)new StandardGlyphVector(this, chars, frc); } /** * Creates a {@link java.awt.font.GlyphVector GlyphVector} by * mapping the specified characters to glyphs one-to-one based on the ! * Unicode cmap in this {@code Font}. This method does no other * processing besides the mapping of glyphs to characters. This * means that this method is not useful for some scripts, such * as Arabic, Hebrew, Thai, and Indic, that require reordering, * shaping, or ligature substitution. ! * @param frc the specified {@code FontRenderContext} ! * @param ci the specified {@code CharacterIterator} ! * @return a new {@code GlyphVector} created with the ! * specified {@code CharacterIterator} and the specified ! * {@code FontRenderContext}. */ public GlyphVector createGlyphVector( FontRenderContext frc, CharacterIterator ci) { return (GlyphVector)new StandardGlyphVector(this, ci, frc); } /** * Creates a {@link java.awt.font.GlyphVector GlyphVector} by * mapping characters to glyphs one-to-one based on the ! * Unicode cmap in this {@code Font}. This method does no other * processing besides the mapping of glyphs to characters. This * means that this method is not useful for some scripts, such * as Arabic, Hebrew, Thai, and Indic, that require reordering, * shaping, or ligature substitution. ! * @param frc the specified {@code FontRenderContext} * @param glyphCodes the specified integer array ! * @return a new {@code GlyphVector} created with the * specified integer array and the specified ! * {@code FontRenderContext}. */ public GlyphVector createGlyphVector( FontRenderContext frc, int [] glyphCodes) { return (GlyphVector)new StandardGlyphVector(this, glyphCodes, frc); } /** ! * Returns a new {@code GlyphVector} object, performing full * layout of the text if possible. Full layout is required for * complex text, such as Arabic or Hindi. Support for different * scripts depends on the font and implementation. * <p> * Layout requires bidi analysis, as performed by ! * {@code Bidi}, and should only be performed on text that * has a uniform direction. The direction is indicated in the * flags parameter,by using LAYOUT_RIGHT_TO_LEFT to indicate a * right-to-left (Arabic and Hebrew) run direction, or * LAYOUT_LEFT_TO_RIGHT to indicate a left-to-right (English) * run direction.
*** 2607,2622 **** * start, or after limit, respectively, should not be examined * for context. * <p> * All other values for the flags parameter are reserved. * ! * @param frc the specified <code>FontRenderContext</code> * @param text the text to layout ! * @param start the start of the text to use for the <code>GlyphVector</code> ! * @param limit the limit of the text to use for the <code>GlyphVector</code> * @param flags control flags as described above ! * @return a new <code>GlyphVector</code> representing the text between * start and limit, with glyphs chosen and positioned so as to best represent * the text * @throws ArrayIndexOutOfBoundsException if start or limit is * out of bounds * @see java.text.Bidi --- 2607,2622 ---- * start, or after limit, respectively, should not be examined * for context. * <p> * All other values for the flags parameter are reserved. * ! * @param frc the specified {@code FontRenderContext} * @param text the text to layout ! * @param start the start of the text to use for the {@code GlyphVector} ! * @param limit the limit of the text to use for the {@code GlyphVector} * @param flags control flags as described above ! * @return a new {@code GlyphVector} representing the text between * start and limit, with glyphs chosen and positioned so as to best represent * the text * @throws ArrayIndexOutOfBoundsException if start or limit is * out of bounds * @see java.text.Bidi
< prev index next >