mirror of
http://git.eaglercraft.rip/eaglercraft/eaglercraft-1.8.git
synced 2025-04-30 02:01:59 -05:00
1066 lines
34 KiB
Java
1066 lines
34 KiB
Java
/*
|
|
* Copyright (c) 1997, 2021, Oracle and/or its affiliates. All rights reserved.
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* This code is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License version 2 only, as
|
|
* published by the Free Software Foundation. Oracle designates this
|
|
* particular file as subject to the "Classpath" exception as provided
|
|
* by Oracle in the LICENSE file that accompanied this code.
|
|
*
|
|
* This code is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
* version 2 for more details (a copy is included in the LICENSE file that
|
|
* accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU General Public License version
|
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
* or visit www.oracle.com if you need additional information or have any
|
|
* questions.
|
|
*/
|
|
|
|
/*
|
|
* (C) Copyright Taligent, Inc. 1996 - 1997, All Rights Reserved
|
|
* (C) Copyright IBM Corp. 1996 - 1998, All Rights Reserved
|
|
*
|
|
* The original version of this source code and documentation is
|
|
* copyrighted and owned by Taligent, Inc., a wholly-owned subsidiary
|
|
* of IBM. These materials are provided under terms of a License
|
|
* Agreement between Taligent and Sun. This technology is protected
|
|
* by multiple US and International patents.
|
|
*
|
|
* This notice and attribution to Taligent may not be removed.
|
|
* Taligent is a registered trademark of Taligent, Inc.
|
|
*
|
|
*/
|
|
|
|
package jdk_internal.bidi;
|
|
|
|
import java.io.InvalidObjectException;
|
|
import java.util.HashMap;
|
|
import java.util.Map;
|
|
|
|
import jdk_internal.bidi.AttributedCharacterIterator.Attribute;
|
|
|
|
/**
|
|
* The {@code TextAttribute} class defines attribute keys and attribute values
|
|
* used for text rendering.
|
|
* <p>
|
|
* {@code TextAttribute} instances are used as attribute keys to identify
|
|
* attributes in {@link java.awt.Font Font}, {@link java.awt.font.TextLayout
|
|
* TextLayout}, {@link java.text.AttributedCharacterIterator
|
|
* AttributedCharacterIterator}, and other classes handling text attributes.
|
|
* Other constants defined in this class can be used as attribute values.
|
|
* <p>
|
|
* For each text attribute, the documentation provides:
|
|
* <UL>
|
|
* <LI>the type of its value,
|
|
* <LI>the relevant predefined constants, if any
|
|
* <LI>the default effect if the attribute is absent
|
|
* <LI>the valid values if there are limitations
|
|
* <LI>a description of the effect.
|
|
* </UL>
|
|
*
|
|
* <H2>Values</H2>
|
|
* <UL>
|
|
* <LI>The values of attributes must always be immutable.
|
|
* <LI>Where value limitations are given, any value outside of that set is
|
|
* reserved for future use; the value will be treated as the default.
|
|
* <LI>The value {@code null} is treated the same as the default value and
|
|
* results in the default behavior.
|
|
* <li>If the value is not of the proper type, the attribute will be ignored.
|
|
* <li>The identity of the value does not matter, only the actual value. For
|
|
* example, {@code TextAttribute.WEIGHT_BOLD} and {@code Float.valueOf(2.0f)}
|
|
* indicate the same {@code WEIGHT}.
|
|
* <li>Attribute values of type {@code Number} (used for {@code WEIGHT},
|
|
* {@code WIDTH}, {@code POSTURE}, {@code SIZE}, {@code JUSTIFICATION}, and
|
|
* {@code TRACKING}) can vary along their natural range and are not restricted
|
|
* to the predefined constants. {@code Number.floatValue()} is used to get the
|
|
* actual value from the {@code Number}.
|
|
* <li>The values for {@code WEIGHT}, {@code WIDTH}, and {@code POSTURE} are
|
|
* interpolated by the system, which can select the 'nearest available' font or
|
|
* use other techniques to approximate the user's request.
|
|
*
|
|
* </UL>
|
|
*
|
|
* <h3>Summary of attributes</h3>
|
|
*
|
|
* <table style="width:95%;margin: 0px auto" class="striped">
|
|
* <caption>Key, value type, principal constants, and default value behavior of
|
|
* all TextAttributes</caption> <thead>
|
|
* <tr>
|
|
* <th scope="col">Key
|
|
* <th scope="col">Value Type
|
|
* <th scope="col">Principal Constants
|
|
* <th scope="col">Default Value </thead> <tbody>
|
|
* <tr>
|
|
* <th scope="row">{@link #FAMILY}
|
|
* <td>String
|
|
* <td>See Font {@link java.awt.Font#DIALOG DIALOG},
|
|
* {@link java.awt.Font#DIALOG_INPUT DIALOG_INPUT}, <br>
|
|
* {@link java.awt.Font#SERIF SERIF}, {@link java.awt.Font#SANS_SERIF
|
|
* SANS_SERIF}, and {@link java.awt.Font#MONOSPACED MONOSPACED}.
|
|
* <td>"Default" (use platform default)
|
|
* <tr>
|
|
* <th scope="row">{@link #WEIGHT}
|
|
* <td>Number
|
|
* <td>WEIGHT_REGULAR, WEIGHT_BOLD
|
|
* <td>WEIGHT_REGULAR
|
|
* <tr>
|
|
* <th scope="row">{@link #WIDTH}
|
|
* <td>Number
|
|
* <td>WIDTH_CONDENSED, WIDTH_REGULAR,<br>
|
|
* WIDTH_EXTENDED
|
|
* <td>WIDTH_REGULAR
|
|
* <tr>
|
|
* <th scope="row">{@link #POSTURE}
|
|
* <td>Number
|
|
* <td>POSTURE_REGULAR, POSTURE_OBLIQUE
|
|
* <td>POSTURE_REGULAR
|
|
* <tr>
|
|
* <th scope="row">{@link #SIZE}
|
|
* <td>Number
|
|
* <td>none
|
|
* <td>12.0
|
|
* <tr>
|
|
* <th scope="row">{@link #TRANSFORM}
|
|
* <td>{@link TransformAttribute}
|
|
* <td>See TransformAttribute {@link TransformAttribute#IDENTITY IDENTITY}
|
|
* <td>TransformAttribute.IDENTITY
|
|
* <tr>
|
|
* <th scope="row">{@link #SUPERSCRIPT}
|
|
* <td>Integer
|
|
* <td>SUPERSCRIPT_SUPER, SUPERSCRIPT_SUB
|
|
* <td>0 (use the standard glyphs and metrics)
|
|
* <tr>
|
|
* <th scope="row">{@link #FONT}
|
|
* <td>{@link java.awt.Font}
|
|
* <td>none
|
|
* <td>null (do not override font resolution)
|
|
* <tr>
|
|
* <th scope="row">{@link #CHAR_REPLACEMENT}
|
|
* <td>{@link GraphicAttribute}
|
|
* <td>none
|
|
* <td>null (draw text using font glyphs)
|
|
* <tr>
|
|
* <th scope="row">{@link #FOREGROUND}
|
|
* <td>{@link java.awt.Paint}
|
|
* <td>none
|
|
* <td>null (use current graphics paint)
|
|
* <tr>
|
|
* <th scope="row">{@link #BACKGROUND}
|
|
* <td>{@link java.awt.Paint}
|
|
* <td>none
|
|
* <td>null (do not render background)
|
|
* <tr>
|
|
* <th scope="row">{@link #UNDERLINE}
|
|
* <td>Integer
|
|
* <td>UNDERLINE_ON
|
|
* <td>-1 (do not render underline)
|
|
* <tr>
|
|
* <th scope="row">{@link #STRIKETHROUGH}
|
|
* <td>Boolean
|
|
* <td>STRIKETHROUGH_ON
|
|
* <td>false (do not render strikethrough)
|
|
* <tr>
|
|
* <th scope="row">{@link #RUN_DIRECTION}
|
|
* <td>Boolean
|
|
* <td>RUN_DIRECTION_LTR<br>
|
|
* RUN_DIRECTION_RTL
|
|
* <td>null (use {@link java.text.Bidi} standard default)
|
|
* <tr>
|
|
* <th scope="row">{@link #BIDI_EMBEDDING}
|
|
* <td>Integer
|
|
* <td>none
|
|
* <td>0 (use base line direction)
|
|
* <tr>
|
|
* <th scope="row">{@link #JUSTIFICATION}
|
|
* <td>Number
|
|
* <td>JUSTIFICATION_FULL
|
|
* <td>JUSTIFICATION_FULL
|
|
* <tr>
|
|
* <th scope="row">{@link #INPUT_METHOD_HIGHLIGHT}
|
|
* <td>{@link java.awt.im.InputMethodHighlight}, <br>
|
|
* {@link java.text.Annotation}
|
|
* <td>(see class)
|
|
* <td>null (do not apply input highlighting)
|
|
* <tr>
|
|
* <th scope="row">{@link #INPUT_METHOD_UNDERLINE}
|
|
* <td>Integer
|
|
* <td>UNDERLINE_LOW_ONE_PIXEL,<br>
|
|
* UNDERLINE_LOW_TWO_PIXEL
|
|
* <td>-1 (do not render underline)
|
|
* <tr>
|
|
* <th scope="row">{@link #SWAP_COLORS}
|
|
* <td>Boolean
|
|
* <td>SWAP_COLORS_ON
|
|
* <td>false (do not swap colors)
|
|
* <tr>
|
|
* <th scope="row">{@link #NUMERIC_SHAPING}
|
|
* <td>{@link java.awt.font.NumericShaper}
|
|
* <td>none
|
|
* <td>null (do not shape digits)
|
|
* <tr>
|
|
* <th scope="row">{@link #KERNING}
|
|
* <td>Integer
|
|
* <td>KERNING_ON
|
|
* <td>0 (do not request kerning)
|
|
* <tr>
|
|
* <th scope="row">{@link #LIGATURES}
|
|
* <td>Integer
|
|
* <td>LIGATURES_ON
|
|
* <td>0 (do not form optional ligatures)
|
|
* <tr>
|
|
* <th scope="row">{@link #TRACKING}
|
|
* <td>Number
|
|
* <td>TRACKING_LOOSE, TRACKING_TIGHT
|
|
* <td>0 (do not add tracking)
|
|
* </tr>
|
|
* </tbody>
|
|
* </table>
|
|
*
|
|
* @see java.awt.Font
|
|
* @see java.awt.font.TextLayout
|
|
* @see java.text.AttributedCharacterIterator
|
|
*/
|
|
public final class TextAttribute extends Attribute {
|
|
|
|
// table of all instances in this class, used by readResolve
|
|
private static final Map<String, TextAttribute> instanceMap = new HashMap<String, TextAttribute>(29);
|
|
|
|
/**
|
|
* Constructs a {@code TextAttribute} with the specified name.
|
|
*
|
|
* @param name the attribute name to assign to this {@code TextAttribute}
|
|
*/
|
|
protected TextAttribute(String name) {
|
|
super(name);
|
|
if (this.getClass() == TextAttribute.class) {
|
|
instanceMap.put(name, this);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Resolves instances being deserialized to the predefined constants.
|
|
*/
|
|
protected Object readResolve() throws InvalidObjectException {
|
|
if (this.getClass() != TextAttribute.class) {
|
|
throw new InvalidObjectException("subclass didn't correctly implement readResolve");
|
|
}
|
|
|
|
TextAttribute instance = instanceMap.get(getName());
|
|
if (instance != null) {
|
|
return instance;
|
|
} else {
|
|
throw new InvalidObjectException("unknown attribute name");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Use serialVersionUID from JDK 1.2 for interoperability. 1.2 will throw an
|
|
* InvalidObjectException if ever asked to deserialize INPUT_METHOD_UNDERLINE.
|
|
* This shouldn't happen in real life.
|
|
*/
|
|
private static final long serialVersionUID = 7744112784117861702L;
|
|
|
|
//
|
|
// For use with Font.
|
|
//
|
|
|
|
/**
|
|
* Attribute key for the font name. Values are instances of
|
|
* <b>{@code String}</b>. The default value is {@code "Default"}, which causes
|
|
* the platform default font family to be used.
|
|
*
|
|
* <p>
|
|
* The {@code Font} class defines constants for the logical font names
|
|
* {@link java.awt.Font#DIALOG DIALOG}, {@link java.awt.Font#DIALOG_INPUT
|
|
* DIALOG_INPUT}, {@link java.awt.Font#SANS_SERIF SANS_SERIF},
|
|
* {@link java.awt.Font#SERIF SERIF}, and {@link java.awt.Font#MONOSPACED
|
|
* MONOSPACED}.
|
|
*
|
|
* <p>
|
|
* This defines the value passed as {@code name} to the {@code Font}
|
|
* constructor. Both logical and physical font names are allowed. If a font with
|
|
* the requested name is not found, the default font is used.
|
|
*
|
|
* <p>
|
|
* <em>Note:</em> This attribute is unfortunately misnamed, as it specifies the
|
|
* face name and not just the family. Thus values such as "Lucida Sans Bold"
|
|
* will select that face if it exists. Note, though, that if the requested face
|
|
* does not exist, the default will be used with <em>regular</em> weight. The
|
|
* "Bold" in the name is part of the face name, not a separate request that the
|
|
* font's weight be bold.
|
|
* </p>
|
|
*/
|
|
public static final TextAttribute FAMILY = new TextAttribute("family");
|
|
|
|
/**
|
|
* Attribute key for the weight of a font. Values are instances of
|
|
* <b>{@code Number}</b>. The default value is {@code WEIGHT_REGULAR}.
|
|
*
|
|
* <p>
|
|
* Several constant values are provided, see {@link #WEIGHT_EXTRA_LIGHT},
|
|
* {@link #WEIGHT_LIGHT}, {@link #WEIGHT_DEMILIGHT}, {@link #WEIGHT_REGULAR},
|
|
* {@link #WEIGHT_SEMIBOLD}, {@link #WEIGHT_MEDIUM}, {@link #WEIGHT_DEMIBOLD},
|
|
* {@link #WEIGHT_BOLD}, {@link #WEIGHT_HEAVY}, {@link #WEIGHT_EXTRABOLD}, and
|
|
* {@link #WEIGHT_ULTRABOLD}. The value {@code WEIGHT_BOLD} corresponds to the
|
|
* style value {@code Font.BOLD} as passed to the {@code Font} constructor.
|
|
*
|
|
* <p>
|
|
* The value is roughly the ratio of the stem width to that of the regular
|
|
* weight.
|
|
*
|
|
* <p>
|
|
* The system can interpolate the provided value.
|
|
*/
|
|
public static final TextAttribute WEIGHT = new TextAttribute("weight");
|
|
|
|
/**
|
|
* The lightest predefined weight.
|
|
*
|
|
* @see #WEIGHT
|
|
*/
|
|
public static final Float WEIGHT_EXTRA_LIGHT = Float.valueOf(0.5f);
|
|
|
|
/**
|
|
* The standard light weight.
|
|
*
|
|
* @see #WEIGHT
|
|
*/
|
|
public static final Float WEIGHT_LIGHT = Float.valueOf(0.75f);
|
|
|
|
/**
|
|
* An intermediate weight between {@code WEIGHT_LIGHT} and
|
|
* {@code WEIGHT_STANDARD}.
|
|
*
|
|
* @see #WEIGHT
|
|
*/
|
|
public static final Float WEIGHT_DEMILIGHT = Float.valueOf(0.875f);
|
|
|
|
/**
|
|
* The standard weight. This is the default value for {@code WEIGHT}.
|
|
*
|
|
* @see #WEIGHT
|
|
*/
|
|
public static final Float WEIGHT_REGULAR = Float.valueOf(1.0f);
|
|
|
|
/**
|
|
* A moderately heavier weight than {@code WEIGHT_REGULAR}.
|
|
*
|
|
* @see #WEIGHT
|
|
*/
|
|
public static final Float WEIGHT_SEMIBOLD = Float.valueOf(1.25f);
|
|
|
|
/**
|
|
* An intermediate weight between {@code WEIGHT_REGULAR} and
|
|
* {@code WEIGHT_BOLD}.
|
|
*
|
|
* @see #WEIGHT
|
|
*/
|
|
public static final Float WEIGHT_MEDIUM = Float.valueOf(1.5f);
|
|
|
|
/**
|
|
* A moderately lighter weight than {@code WEIGHT_BOLD}.
|
|
*
|
|
* @see #WEIGHT
|
|
*/
|
|
public static final Float WEIGHT_DEMIBOLD = Float.valueOf(1.75f);
|
|
|
|
/**
|
|
* The standard bold weight.
|
|
*
|
|
* @see #WEIGHT
|
|
*/
|
|
public static final Float WEIGHT_BOLD = Float.valueOf(2.0f);
|
|
|
|
/**
|
|
* A moderately heavier weight than {@code WEIGHT_BOLD}.
|
|
*
|
|
* @see #WEIGHT
|
|
*/
|
|
public static final Float WEIGHT_HEAVY = Float.valueOf(2.25f);
|
|
|
|
/**
|
|
* An extra heavy weight.
|
|
*
|
|
* @see #WEIGHT
|
|
*/
|
|
public static final Float WEIGHT_EXTRABOLD = Float.valueOf(2.5f);
|
|
|
|
/**
|
|
* The heaviest predefined weight.
|
|
*
|
|
* @see #WEIGHT
|
|
*/
|
|
public static final Float WEIGHT_ULTRABOLD = Float.valueOf(2.75f);
|
|
|
|
/**
|
|
* Attribute key for the width of a font. Values are instances of
|
|
* <b>{@code Number}</b>. The default value is {@code WIDTH_REGULAR}.
|
|
*
|
|
* <p>
|
|
* Several constant values are provided, see {@link #WIDTH_CONDENSED},
|
|
* {@link #WIDTH_SEMI_CONDENSED}, {@link #WIDTH_REGULAR},
|
|
* {@link #WIDTH_SEMI_EXTENDED}, {@link #WIDTH_EXTENDED}.
|
|
*
|
|
* <p>
|
|
* The value is roughly the ratio of the advance width to that of the regular
|
|
* width.
|
|
*
|
|
* <p>
|
|
* The system can interpolate the provided value.
|
|
*/
|
|
public static final TextAttribute WIDTH = new TextAttribute("width");
|
|
|
|
/**
|
|
* The most condensed predefined width.
|
|
*
|
|
* @see #WIDTH
|
|
*/
|
|
public static final Float WIDTH_CONDENSED = Float.valueOf(0.75f);
|
|
|
|
/**
|
|
* A moderately condensed width.
|
|
*
|
|
* @see #WIDTH
|
|
*/
|
|
public static final Float WIDTH_SEMI_CONDENSED = Float.valueOf(0.875f);
|
|
|
|
/**
|
|
* The standard width. This is the default value for {@code WIDTH}.
|
|
*
|
|
* @see #WIDTH
|
|
*/
|
|
public static final Float WIDTH_REGULAR = Float.valueOf(1.0f);
|
|
|
|
/**
|
|
* A moderately extended width.
|
|
*
|
|
* @see #WIDTH
|
|
*/
|
|
public static final Float WIDTH_SEMI_EXTENDED = Float.valueOf(1.25f);
|
|
|
|
/**
|
|
* The most extended predefined width.
|
|
*
|
|
* @see #WIDTH
|
|
*/
|
|
public static final Float WIDTH_EXTENDED = Float.valueOf(1.5f);
|
|
|
|
/**
|
|
* Attribute key for the posture of a font. Values are instances of
|
|
* <b>{@code Number}</b>. The default value is {@code POSTURE_REGULAR}.
|
|
*
|
|
* <p>
|
|
* Two constant values are provided, {@link #POSTURE_REGULAR} and
|
|
* {@link #POSTURE_OBLIQUE}. The value {@code POSTURE_OBLIQUE} corresponds to
|
|
* the style value {@code Font.ITALIC} as passed to the {@code Font}
|
|
* constructor.
|
|
*
|
|
* <p>
|
|
* The value is roughly the slope of the stems of the font, expressed as the run
|
|
* over the rise. Positive values lean right.
|
|
*
|
|
* <p>
|
|
* The system can interpolate the provided value.
|
|
*
|
|
* <p>
|
|
* This will affect the font's italic angle as returned by
|
|
* {@code Font.getItalicAngle}.
|
|
*
|
|
* @see java.awt.Font#getItalicAngle()
|
|
*/
|
|
public static final TextAttribute POSTURE = new TextAttribute("posture");
|
|
|
|
/**
|
|
* The standard posture, upright. This is the default value for {@code POSTURE}.
|
|
*
|
|
* @see #POSTURE
|
|
*/
|
|
public static final Float POSTURE_REGULAR = Float.valueOf(0.0f);
|
|
|
|
/**
|
|
* The standard italic posture.
|
|
*
|
|
* @see #POSTURE
|
|
*/
|
|
public static final Float POSTURE_OBLIQUE = Float.valueOf(0.20f);
|
|
|
|
/**
|
|
* Attribute key for the font size. Values are instances of
|
|
* <b>{@code Number}</b>. The default value is 12pt.
|
|
*
|
|
* <p>
|
|
* This corresponds to the {@code size} parameter to the {@code Font}
|
|
* constructor.
|
|
*
|
|
* <p>
|
|
* Very large or small sizes will impact rendering performance, and the
|
|
* rendering system might not render text at these sizes. Negative sizes are
|
|
* illegal and result in the default size.
|
|
*
|
|
* <p>
|
|
* Note that the appearance and metrics of a 12pt font with a 2x transform might
|
|
* be different than that of a 24 point font with no transform.
|
|
*/
|
|
public static final TextAttribute SIZE = new TextAttribute("size");
|
|
|
|
/**
|
|
* Attribute key for the transform of a font. Values are instances of
|
|
* <b>{@code TransformAttribute}</b>. The default value is
|
|
* {@code TransformAttribute.IDENTITY}.
|
|
*
|
|
* <p>
|
|
* The {@code TransformAttribute} class defines the constant
|
|
* {@link TransformAttribute#IDENTITY IDENTITY}.
|
|
*
|
|
* <p>
|
|
* This corresponds to the transform passed to
|
|
* {@code Font.deriveFont(AffineTransform)}. Since that transform is mutable and
|
|
* {@code TextAttribute} values must not be, the {@code TransformAttribute}
|
|
* wrapper class is used.
|
|
*
|
|
* <p>
|
|
* The primary intent is to support scaling and skewing, though other effects
|
|
* are possible.
|
|
* </p>
|
|
*
|
|
* <p>
|
|
* Some transforms will cause the baseline to be rotated and/or shifted. The
|
|
* text and the baseline are transformed together so that the text follows the
|
|
* new baseline. For example, with text on a horizontal baseline, the new
|
|
* baseline follows the direction of the unit x vector passed through the
|
|
* transform. Text metrics are measured against this new baseline. So, for
|
|
* example, with other things being equal, text rendered with a rotated
|
|
* TRANSFORM and an unrotated TRANSFORM will measure as having the same ascent,
|
|
* descent, and advance.
|
|
* </p>
|
|
*
|
|
* <p>
|
|
* In styled text, the baselines for each such run are aligned one after the
|
|
* other to potentially create a non-linear baseline for the entire run of text.
|
|
* For more information, see {@link TextLayout#getLayoutPath}.
|
|
* </p>
|
|
*
|
|
* @see TransformAttribute
|
|
* @see java.awt.geom.AffineTransform
|
|
*/
|
|
public static final TextAttribute TRANSFORM = new TextAttribute("transform");
|
|
|
|
/**
|
|
* Attribute key for superscripting and subscripting. Values are instances of
|
|
* <b>{@code Integer}</b>. The default value is 0, which means that no
|
|
* superscript or subscript is used.
|
|
*
|
|
* <p>
|
|
* Two constant values are provided, see {@link #SUPERSCRIPT_SUPER} and
|
|
* {@link #SUPERSCRIPT_SUB}. These have the values 1 and -1 respectively. Values
|
|
* of greater magnitude define greater levels of superscript or subscripting,
|
|
* for example, 2 corresponds to super-superscript, 3 to
|
|
* super-super-superscript, and similarly for negative values and subscript, up
|
|
* to a level of 7 (or -7). Values beyond this range are reserved; behavior is
|
|
* platform-dependent.
|
|
*
|
|
* <p>
|
|
* {@code SUPERSCRIPT} can impact the ascent and descent of a font. The ascent
|
|
* and descent can never become negative, however.
|
|
*/
|
|
public static final TextAttribute SUPERSCRIPT = new TextAttribute("superscript");
|
|
|
|
/**
|
|
* Standard superscript.
|
|
*
|
|
* @see #SUPERSCRIPT
|
|
*/
|
|
public static final Integer SUPERSCRIPT_SUPER = Integer.valueOf(1);
|
|
|
|
/**
|
|
* Standard subscript.
|
|
*
|
|
* @see #SUPERSCRIPT
|
|
*/
|
|
public static final Integer SUPERSCRIPT_SUB = Integer.valueOf(-1);
|
|
|
|
/**
|
|
* Attribute key used to provide the font to use to render text. Values are
|
|
* instances of {@link java.awt.Font}. The default value is null, indicating
|
|
* that normal resolution of a {@code Font} from attributes should be performed.
|
|
*
|
|
* <p>
|
|
* {@code TextLayout} and {@code AttributedCharacterIterator} work in terms of
|
|
* {@code Maps} of {@code TextAttributes}. Normally, all the attributes are
|
|
* examined and used to select and configure a {@code Font} instance. If a
|
|
* {@code FONT} attribute is present, though, its associated {@code Font} will
|
|
* be used. This provides a way for users to override the resolution of font
|
|
* attributes into a {@code Font}, or force use of a particular {@code Font}
|
|
* instance. This also allows users to specify subclasses of {@code Font} in
|
|
* cases where a {@code Font} can be subclassed.
|
|
*
|
|
* <p>
|
|
* {@code FONT} is used for special situations where clients already have a
|
|
* {@code Font} instance but still need to use {@code Map}-based APIs.
|
|
* Typically, there will be no other attributes in the {@code Map} except the
|
|
* {@code FONT} attribute. With {@code Map}-based APIs the common case is to
|
|
* specify all attributes individually, so {@code FONT} is not needed or
|
|
* desirable.
|
|
*
|
|
* <p>
|
|
* However, if both {@code FONT} and other attributes are present in the
|
|
* {@code Map}, the rendering system will merge the attributes defined in the
|
|
* {@code Font} with the additional attributes. This merging process classifies
|
|
* {@code TextAttributes} into two groups. One group, the 'primary' group, is
|
|
* considered fundamental to the selection and metric behavior of a font. These
|
|
* attributes are {@code FAMILY}, {@code WEIGHT}, {@code WIDTH},
|
|
* {@code POSTURE}, {@code SIZE}, {@code TRANSFORM}, {@code SUPERSCRIPT}, and
|
|
* {@code TRACKING}. The other group, the 'secondary' group, consists of all
|
|
* other defined attributes, with the exception of {@code FONT} itself.
|
|
*
|
|
* <p>
|
|
* To generate the new {@code Map}, first the {@code Font} is obtained from the
|
|
* {@code FONT} attribute, and <em>all</em> of its attributes extracted into a
|
|
* new {@code Map}. Then only the <em>secondary</em> attributes from the
|
|
* original {@code Map} are added to those in the new {@code Map}. Thus the
|
|
* values of primary attributes come solely from the {@code Font}, and the
|
|
* values of secondary attributes originate with the {@code Font} but can be
|
|
* overridden by other values in the {@code Map}.
|
|
*
|
|
* <p>
|
|
* <em>Note:</em>{@code Font's Map}-based constructor and {@code deriveFont}
|
|
* methods do not process the {@code FONT} attribute, as these are used to
|
|
* create new {@code Font} objects. Instead, {@link java.awt.Font#getFont(Map)
|
|
* Font.getFont(Map)} should be used to handle the {@code FONT} attribute.
|
|
*
|
|
* @see java.awt.Font
|
|
*/
|
|
public static final TextAttribute FONT = new TextAttribute("font");
|
|
|
|
/**
|
|
* Attribute key for a user-defined glyph to display in lieu of the font's
|
|
* standard glyph for a character. Values are instances of GraphicAttribute. The
|
|
* default value is null, indicating that the standard glyphs provided by the
|
|
* font should be used.
|
|
*
|
|
* <p>
|
|
* This attribute is used to reserve space for a graphic or other component
|
|
* embedded in a line of text. It is required for correct positioning of
|
|
* 'inline' components within a line when bidirectional reordering (see
|
|
* {@link java.text.Bidi}) is performed. Each character (Unicode code point)
|
|
* will be rendered using the provided GraphicAttribute. Typically, the
|
|
* characters to which this attribute is applied should be
|
|
* <code>\uFFFC</code>.
|
|
*
|
|
* <p>
|
|
* The GraphicAttribute determines the logical and visual bounds of the text;
|
|
* the actual Font values are ignored.
|
|
*
|
|
* @see GraphicAttribute
|
|
*/
|
|
public static final TextAttribute CHAR_REPLACEMENT = new TextAttribute("char_replacement");
|
|
|
|
//
|
|
// Adornments added to text.
|
|
//
|
|
|
|
/**
|
|
* Attribute key for the paint used to render the text. Values are instances of
|
|
* <b>{@code Paint}</b>. The default value is null, indicating that the
|
|
* {@code Paint} set on the {@code Graphics2D} at the time of rendering is used.
|
|
*
|
|
* <p>
|
|
* Glyphs will be rendered using this {@code Paint} regardless of the
|
|
* {@code Paint} value set on the {@code Graphics} (but see
|
|
* {@link #SWAP_COLORS}).
|
|
*
|
|
* @see java.awt.Paint
|
|
* @see #SWAP_COLORS
|
|
*/
|
|
public static final TextAttribute FOREGROUND = new TextAttribute("foreground");
|
|
|
|
/**
|
|
* Attribute key for the paint used to render the background of the text. Values
|
|
* are instances of <b>{@code Paint}</b>. The default value is null, indicating
|
|
* that the background should not be rendered.
|
|
*
|
|
* <p>
|
|
* The logical bounds of the text will be filled using this {@code Paint}, and
|
|
* then the text will be rendered on top of it (but see {@link #SWAP_COLORS}).
|
|
*
|
|
* <p>
|
|
* The visual bounds of the text is extended to include the logical bounds, if
|
|
* necessary. The outline is not affected.
|
|
*
|
|
* @see java.awt.Paint
|
|
* @see #SWAP_COLORS
|
|
*/
|
|
public static final TextAttribute BACKGROUND = new TextAttribute("background");
|
|
|
|
/**
|
|
* Attribute key for underline. Values are instances of <b>{@code Integer}</b>.
|
|
* The default value is -1, which means no underline.
|
|
*
|
|
* <p>
|
|
* The constant value {@link #UNDERLINE_ON} is provided.
|
|
*
|
|
* <p>
|
|
* The underline affects both the visual bounds and the outline of the text.
|
|
*/
|
|
public static final TextAttribute UNDERLINE = new TextAttribute("underline");
|
|
|
|
/**
|
|
* Standard underline.
|
|
*
|
|
* @see #UNDERLINE
|
|
*/
|
|
public static final Integer UNDERLINE_ON = Integer.valueOf(0);
|
|
|
|
/**
|
|
* Attribute key for strikethrough. Values are instances of
|
|
* <b>{@code Boolean}</b>. The default value is {@code false}, which means no
|
|
* strikethrough.
|
|
*
|
|
* <p>
|
|
* The constant value {@link #STRIKETHROUGH_ON} is provided.
|
|
*
|
|
* <p>
|
|
* The strikethrough affects both the visual bounds and the outline of the text.
|
|
*/
|
|
public static final TextAttribute STRIKETHROUGH = new TextAttribute("strikethrough");
|
|
|
|
/**
|
|
* A single strikethrough.
|
|
*
|
|
* @see #STRIKETHROUGH
|
|
*/
|
|
public static final Boolean STRIKETHROUGH_ON = Boolean.TRUE;
|
|
|
|
//
|
|
// Attributes use to control layout of text on a line.
|
|
//
|
|
|
|
/**
|
|
* Attribute key for the run direction of the line. Values are instances of
|
|
* <b>{@code Boolean}</b>. The default value is null, which indicates that the
|
|
* standard Bidi algorithm for determining run direction should be used with the
|
|
* value {@link java.text.Bidi#DIRECTION_DEFAULT_LEFT_TO_RIGHT}.
|
|
*
|
|
* <p>
|
|
* The constants {@link #RUN_DIRECTION_RTL} and {@link #RUN_DIRECTION_LTR} are
|
|
* provided.
|
|
*
|
|
* <p>
|
|
* This determines the value passed to the {@link java.text.Bidi} constructor to
|
|
* select the primary direction of the text in the paragraph.
|
|
*
|
|
* <p>
|
|
* <em>Note:</em> This attribute should have the same value for all the text in
|
|
* a paragraph, otherwise the behavior is undetermined.
|
|
*
|
|
* @see java.text.Bidi
|
|
*/
|
|
public static final TextAttribute RUN_DIRECTION = new TextAttribute("run_direction");
|
|
|
|
/**
|
|
* Left-to-right run direction.
|
|
*
|
|
* @see #RUN_DIRECTION
|
|
*/
|
|
public static final Boolean RUN_DIRECTION_LTR = Boolean.FALSE;
|
|
|
|
/**
|
|
* Right-to-left run direction.
|
|
*
|
|
* @see #RUN_DIRECTION
|
|
*/
|
|
public static final Boolean RUN_DIRECTION_RTL = Boolean.TRUE;
|
|
|
|
/**
|
|
* Attribute key for the embedding level of the text. Values are instances of
|
|
* <b>{@code Integer}</b>. The default value is {@code null}, indicating that
|
|
* the Bidirectional algorithm should run without explicit embeddings.
|
|
*
|
|
* <p>
|
|
* Positive values 1 through 61 are <em>embedding</em> levels, negative values
|
|
* -1 through -61 are <em>override</em> levels. The value 0 means that the base
|
|
* line direction is used. These levels are passed in the embedding levels array
|
|
* to the {@link java.text.Bidi} constructor.
|
|
*
|
|
* <p>
|
|
* <em>Note:</em> When this attribute is present anywhere in a paragraph, then
|
|
* any Unicode bidi control characters (RLO, LRO, RLE, LRE, and PDF) in the
|
|
* paragraph are disregarded, and runs of text where this attribute is not
|
|
* present are treated as though it were present and had the value 0.
|
|
*
|
|
* @see java.text.Bidi
|
|
*/
|
|
public static final TextAttribute BIDI_EMBEDDING = new TextAttribute("bidi_embedding");
|
|
|
|
/**
|
|
* Attribute key for the justification of a paragraph. Values are instances of
|
|
* <b>{@code Number}</b>. The default value is 1, indicating that justification
|
|
* should use the full width provided. Values are pinned to the range [0..1].
|
|
*
|
|
* <p>
|
|
* The constants {@link #JUSTIFICATION_FULL} and {@link #JUSTIFICATION_NONE} are
|
|
* provided.
|
|
*
|
|
* <p>
|
|
* Specifies the fraction of the extra space to use when justification is
|
|
* requested on a {@code TextLayout}. For example, if the line is 50 points wide
|
|
* and it is requested to justify to 70 points, a value of 0.75 will pad to use
|
|
* three-quarters of the remaining space, or 15 points, so that the resulting
|
|
* line will be 65 points in length.
|
|
*
|
|
* <p>
|
|
* <em>Note:</em> This should have the same value for all the text in a
|
|
* paragraph, otherwise the behavior is undetermined.
|
|
*
|
|
* @see TextLayout#getJustifiedLayout
|
|
*/
|
|
public static final TextAttribute JUSTIFICATION = new TextAttribute("justification");
|
|
|
|
/**
|
|
* Justify the line to the full requested width. This is the default value for
|
|
* {@code JUSTIFICATION}.
|
|
*
|
|
* @see #JUSTIFICATION
|
|
*/
|
|
public static final Float JUSTIFICATION_FULL = Float.valueOf(1.0f);
|
|
|
|
/**
|
|
* Do not allow the line to be justified.
|
|
*
|
|
* @see #JUSTIFICATION
|
|
*/
|
|
public static final Float JUSTIFICATION_NONE = Float.valueOf(0.0f);
|
|
|
|
//
|
|
// For use by input method.
|
|
//
|
|
|
|
/**
|
|
* Attribute key for input method highlight styles.
|
|
*
|
|
* <p>
|
|
* Values are instances of {@link java.awt.im.InputMethodHighlight} or
|
|
* {@link java.text.Annotation}. The default value is {@code null}, which means
|
|
* that input method styles should not be applied before rendering.
|
|
*
|
|
* <p>
|
|
* If adjacent runs of text with the same {@code InputMethodHighlight} need to
|
|
* be rendered separately, the {@code InputMethodHighlights} should be wrapped
|
|
* in {@code Annotation} instances.
|
|
*
|
|
* <p>
|
|
* Input method highlights are used while text is being composed by an input
|
|
* method. Text editing components should retain them even if they generally
|
|
* only deal with unstyled text, and make them available to the drawing
|
|
* routines.
|
|
*
|
|
* @see java.awt.Font
|
|
* @see java.awt.im.InputMethodHighlight
|
|
* @see java.text.Annotation
|
|
*/
|
|
public static final TextAttribute INPUT_METHOD_HIGHLIGHT = new TextAttribute("input method highlight");
|
|
|
|
/**
|
|
* Attribute key for input method underlines. Values are instances of
|
|
* <b>{@code Integer}</b>. The default value is {@code -1}, which means no
|
|
* underline.
|
|
*
|
|
* <p>
|
|
* Several constant values are provided, see {@link #UNDERLINE_LOW_ONE_PIXEL},
|
|
* {@link #UNDERLINE_LOW_TWO_PIXEL}, {@link #UNDERLINE_LOW_DOTTED},
|
|
* {@link #UNDERLINE_LOW_GRAY}, and {@link #UNDERLINE_LOW_DASHED}.
|
|
*
|
|
* <p>
|
|
* This may be used in conjunction with {@link #UNDERLINE} if desired. The
|
|
* primary purpose is for use by input methods. Other use of these underlines
|
|
* for simple ornamentation might confuse users.
|
|
*
|
|
* <p>
|
|
* The input method underline affects both the visual bounds and the outline of
|
|
* the text.
|
|
*
|
|
* @since 1.3
|
|
*/
|
|
public static final TextAttribute INPUT_METHOD_UNDERLINE = new TextAttribute("input method underline");
|
|
|
|
/**
|
|
* Single pixel solid low underline.
|
|
*
|
|
* @see #INPUT_METHOD_UNDERLINE
|
|
* @since 1.3
|
|
*/
|
|
public static final Integer UNDERLINE_LOW_ONE_PIXEL = Integer.valueOf(1);
|
|
|
|
/**
|
|
* Double pixel solid low underline.
|
|
*
|
|
* @see #INPUT_METHOD_UNDERLINE
|
|
* @since 1.3
|
|
*/
|
|
public static final Integer UNDERLINE_LOW_TWO_PIXEL = Integer.valueOf(2);
|
|
|
|
/**
|
|
* Single pixel dotted low underline.
|
|
*
|
|
* @see #INPUT_METHOD_UNDERLINE
|
|
* @since 1.3
|
|
*/
|
|
public static final Integer UNDERLINE_LOW_DOTTED = Integer.valueOf(3);
|
|
|
|
/**
|
|
* Double pixel gray low underline.
|
|
*
|
|
* @see #INPUT_METHOD_UNDERLINE
|
|
* @since 1.3
|
|
*/
|
|
public static final Integer UNDERLINE_LOW_GRAY = Integer.valueOf(4);
|
|
|
|
/**
|
|
* Single pixel dashed low underline.
|
|
*
|
|
* @see #INPUT_METHOD_UNDERLINE
|
|
* @since 1.3
|
|
*/
|
|
public static final Integer UNDERLINE_LOW_DASHED = Integer.valueOf(5);
|
|
|
|
/**
|
|
* Attribute key for swapping foreground and background {@code Paints}. Values
|
|
* are instances of <b>{@code Boolean}</b>. The default value is {@code false},
|
|
* which means do not swap colors.
|
|
*
|
|
* <p>
|
|
* The constant value {@link #SWAP_COLORS_ON} is defined.
|
|
*
|
|
* <p>
|
|
* If the {@link #FOREGROUND} attribute is set, its {@code Paint} will be used
|
|
* as the background, otherwise the {@code Paint} currently on the
|
|
* {@code Graphics} will be used. If the {@link #BACKGROUND} attribute is set,
|
|
* its {@code Paint} will be used as the foreground, otherwise the system will
|
|
* find a contrasting color to the (resolved) background so that the text will
|
|
* be visible.
|
|
*
|
|
* @see #FOREGROUND
|
|
* @see #BACKGROUND
|
|
*/
|
|
public static final TextAttribute SWAP_COLORS = new TextAttribute("swap_colors");
|
|
|
|
/**
|
|
* Swap foreground and background.
|
|
*
|
|
* @see #SWAP_COLORS
|
|
* @since 1.3
|
|
*/
|
|
public static final Boolean SWAP_COLORS_ON = Boolean.TRUE;
|
|
|
|
/**
|
|
* Attribute key for converting ASCII decimal digits to other decimal ranges.
|
|
* Values are instances of {@link NumericShaper}. The default is {@code null},
|
|
* which means do not perform numeric shaping.
|
|
*
|
|
* <p>
|
|
* When a numeric shaper is defined, the text is first processed by the shaper
|
|
* before any other analysis of the text is performed.
|
|
*
|
|
* <p>
|
|
* <em>Note:</em> This should have the same value for all the text in the
|
|
* paragraph, otherwise the behavior is undetermined.
|
|
*
|
|
* @see NumericShaper
|
|
* @since 1.4
|
|
*/
|
|
public static final TextAttribute NUMERIC_SHAPING = new TextAttribute("numeric_shaping");
|
|
|
|
/**
|
|
* Attribute key to request kerning. Values are instances of
|
|
* <b>{@code Integer}</b>. The default value is {@code 0}, which does not
|
|
* request kerning.
|
|
*
|
|
* <p>
|
|
* The constant value {@link #KERNING_ON} is provided.
|
|
*
|
|
* <p>
|
|
* The default advances of single characters are not appropriate for some
|
|
* character sequences, for example "To" or "AWAY". Without kerning the adjacent
|
|
* characters appear to be separated by too much space. Kerning causes selected
|
|
* sequences of characters to be spaced differently for a more pleasing visual
|
|
* appearance.
|
|
*
|
|
* @since 1.6
|
|
*/
|
|
public static final TextAttribute KERNING = new TextAttribute("kerning");
|
|
|
|
/**
|
|
* Request standard kerning.
|
|
*
|
|
* @see #KERNING
|
|
* @since 1.6
|
|
*/
|
|
public static final Integer KERNING_ON = Integer.valueOf(1);
|
|
|
|
/**
|
|
* Attribute key for enabling optional ligatures. Values are instances of
|
|
* <b>{@code Integer}</b>. The default value is {@code 0}, which means do not
|
|
* use optional ligatures.
|
|
*
|
|
* <p>
|
|
* The constant value {@link #LIGATURES_ON} is defined.
|
|
*
|
|
* <p>
|
|
* Ligatures required by the writing system are always enabled.
|
|
*
|
|
* @since 1.6
|
|
*/
|
|
public static final TextAttribute LIGATURES = new TextAttribute("ligatures");
|
|
|
|
/**
|
|
* Request standard optional ligatures.
|
|
*
|
|
* @see #LIGATURES
|
|
* @since 1.6
|
|
*/
|
|
public static final Integer LIGATURES_ON = Integer.valueOf(1);
|
|
|
|
/**
|
|
* Attribute key to control tracking. Values are instances of
|
|
* <b>{@code Number}</b>. The default value is {@code 0}, which means no
|
|
* additional tracking.
|
|
*
|
|
* <p>
|
|
* The constant values {@link #TRACKING_TIGHT} and {@link #TRACKING_LOOSE} are
|
|
* provided.
|
|
*
|
|
* <p>
|
|
* The tracking value is multiplied by the font point size and passed through
|
|
* the font transform to determine an additional amount to add to the advance of
|
|
* each glyph cluster. Positive tracking values will inhibit formation of
|
|
* optional ligatures. Tracking values are typically between {@code -0.1} and
|
|
* {@code 0.3}; values outside this range are generally not desirable.
|
|
*
|
|
* @since 1.6
|
|
*/
|
|
public static final TextAttribute TRACKING = new TextAttribute("tracking");
|
|
|
|
/**
|
|
* Perform tight tracking.
|
|
*
|
|
* @see #TRACKING
|
|
* @since 1.6
|
|
*/
|
|
public static final Float TRACKING_TIGHT = Float.valueOf(-.04f);
|
|
|
|
/**
|
|
* Perform loose tracking.
|
|
*
|
|
* @see #TRACKING
|
|
* @since 1.6
|
|
*/
|
|
public static final Float TRACKING_LOOSE = Float.valueOf(.04f);
|
|
}
|