< 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 >