https://openjdk.java.net/ 
/*
 * Copyright (c) 1997, 2017, 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 java.awt.font;

import java.io.InvalidObjectException;
import java.text.AttributedCharacterIterator.Attribute;
import java.util.Map;
import java.util.HashMap;
import jdk.internal.misc.SharedSecrets;


The TextAttribute class defines attribute keys and attribute values used for text rendering. 
 TextAttribute instances are used as attribute keys to identify attributes in Font, TextLayout, AttributedCharacterIterator, and other classes handling text attributes. Other constants defined in this class can be used as attribute values. 

For each text attribute, the documentation provides:

    
  
  • the type of its value,
  
  • the relevant predefined constants, if any
  
  • the default effect if the attribute is absent
  
  • the valid values if there are limitations
  
  • a description of the effect.



Values


    
  
  • The values of attributes must always be immutable.
  
  • Where value limitations are given, any value outside of that
  set is reserved for future use; the value will be treated as
  the default.
  
  • The value null is treated the same as the default value and results in the default behavior. 
  • If the value is not of the proper type, the attribute
  will be ignored.
  
  • The identity of the value does not matter, only the actual value. For example, TextAttribute.WEIGHT_BOLD and Float.valueOf(2.0f) indicate the same WEIGHT. 
  • Attribute values of type Number (used for WEIGHT, WIDTH, POSTURE, SIZE, JUSTIFICATION, and TRACKING) can vary along their natural range and are not restricted to the predefined constants. Number.floatValue() is used to get the actual value from the Number. 
  • The values for WEIGHT, WIDTH, and POSTURE are interpolated by the system, which can select the 'nearest available' font or use other techniques to approximate the user's request. 


Summary of attributes



Key, value type, principal constants, and default value behavior of
all TextAttributes

  

    Key
    Value Type
    Principal Constants
    Default Value



  

    FAMILY String
    See Font DIALOG, DIALOG_INPUT, 
 SERIF, SANS_SERIF, and MONOSPACED. 		"Default" (use platform default)
  

    WEIGHT Number
    WEIGHT_REGULAR, WEIGHT_BOLD
    WEIGHT_REGULAR
  

    WIDTH Number
    WIDTH_CONDENSED, WIDTH_REGULAR,
WIDTH_EXTENDED
    		WIDTH_REGULAR
  

    POSTURE Number
    POSTURE_REGULAR, POSTURE_OBLIQUE
    POSTURE_REGULAR
  

    SIZE Number
    none
    12.0
  

    TRANSFORM TransformAttribute See TransformAttribute IDENTITY TransformAttribute.IDENTITY
  

    SUPERSCRIPT Integer
    SUPERSCRIPT_SUPER, SUPERSCRIPT_SUB
    0 (use the standard glyphs and metrics)
  

    FONT Font none
    null (do not override font resolution)
  

    CHAR_REPLACEMENT GraphicAttribute none
    null (draw text using font glyphs)
  

    FOREGROUND Paint none
    null (use current graphics paint)
  

    BACKGROUND Paint none
    null (do not render background)
  

    UNDERLINE Integer
    UNDERLINE_ON
    -1 (do not render underline)
  

    STRIKETHROUGH Boolean
    STRIKETHROUGH_ON
    false (do not render strikethrough)
  

    RUN_DIRECTION Boolean
    RUN_DIRECTION_LTR
RUN_DIRECTION_RTL
    		null (use Bidi standard default) 

    BIDI_EMBEDDING Integer
    none
    0 (use base line direction)
  

    JUSTIFICATION Number
    JUSTIFICATION_FULL
    JUSTIFICATION_FULL
  

    INPUT_METHOD_HIGHLIGHT InputMethodHighlight, 
 Annotation 		(see class)
    null (do not apply input highlighting)
  

    INPUT_METHOD_UNDERLINE Integer
    UNDERLINE_LOW_ONE_PIXEL,
UNDERLINE_LOW_TWO_PIXEL
    		-1 (do not render underline)
  

    SWAP_COLORS Boolean
    SWAP_COLORS_ON
    false (do not swap colors)
  

    NUMERIC_SHAPING NumericShaper none
    null (do not shape digits)
  

    KERNING Integer
    KERNING_ON
    0 (do not request kerning)
  

    LIGATURES Integer
    LIGATURES_ON
    0 (do not form optional ligatures)
  

    TRACKING Number
    TRACKING_LOOSE, TRACKING_TIGHT
    0 (do not add tracking)
  





See Also:
/**
 * 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>
 *
 * <H3>Values</H3>
 * <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>
 *
 * <h4>Summary of attributes</h4>
 *
 * <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);

    // For access from java.text.Bidi
    static {
        if (SharedSecrets.getJavaAWTFontAccess() == null) {
            SharedSecrets.setJavaAWTFontAccess(new JavaAWTFontAccessImpl());
        }
    }

    
Constructs a TextAttribute with the specified name. 
Params:
  • name – the attribute name to assign to this TextAttribute
/**
     * 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.

/**
     * 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");
        }
    }

    // Serialization compatibility with Java 2 platform v1.2.
    // 1.2 will throw an InvalidObjectException if ever asked to
    // deserialize INPUT_METHOD_UNDERLINE.
    // This shouldn't happen in real life.
    static final long serialVersionUID = 7744112784117861702L;

    //
    // For use with Font.
    //

    
Attribute key for the font name.  Values are instances of
String. The default value is "Default", which causes the platform default font family to be used. 
 The Font class defines constants for the logical font names DIALOG, DIALOG_INPUT, SANS_SERIF, SERIF, and MONOSPACED. 
This defines the value passed as name to the 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. 
Note: 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 regular weight.
The "Bold" in the name is part of the face name, not a separate
request that the font's weight be bold.


/**
     * 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 Number. The default value is WEIGHT_REGULAR. 
Several constant values are provided, see WEIGHT_EXTRA_LIGHT, WEIGHT_LIGHT, WEIGHT_DEMILIGHT, WEIGHT_REGULAR, WEIGHT_SEMIBOLD, WEIGHT_MEDIUM, WEIGHT_DEMIBOLD, WEIGHT_BOLD, WEIGHT_HEAVY, WEIGHT_EXTRABOLD, and WEIGHT_ULTRABOLD. The value WEIGHT_BOLD corresponds to the style value Font.BOLD as passed to the Font constructor. 
The value is roughly the ratio of the stem width to that of
the regular weight.

The system can interpolate the provided value.

/**
     * 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 Also:
  • WEIGHT
/**
     * The lightest predefined weight.
     * @see #WEIGHT
     */
    public static final Float WEIGHT_EXTRA_LIGHT =
        Float.valueOf(0.5f);

    
The standard light weight.

See Also:
  • WEIGHT
/**
     * The standard light weight.
     * @see #WEIGHT
     */
    public static final Float WEIGHT_LIGHT =
        Float.valueOf(0.75f);

    
An intermediate weight between WEIGHT_LIGHT and WEIGHT_STANDARD. 
See Also:
/**
     * 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 WEIGHT. 
See Also:
/**
     * 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 WEIGHT_REGULAR. 
See Also:
/**
     * A moderately heavier weight than {@code WEIGHT_REGULAR}.
     * @see #WEIGHT
     */
    public static final Float WEIGHT_SEMIBOLD =
        Float.valueOf(1.25f);

    
An intermediate weight between WEIGHT_REGULAR and WEIGHT_BOLD. 
See Also:
/**
     * 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 WEIGHT_BOLD. 
See Also:
/**
     * 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 Also:
  • WEIGHT
/**
     * The standard bold weight.
     * @see #WEIGHT
     */
    public static final Float WEIGHT_BOLD =
        Float.valueOf(2.0f);

    
A moderately heavier weight than WEIGHT_BOLD. 
See Also:
/**
     * 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 Also:
  • WEIGHT
/**
     * An extra heavy weight.
     * @see #WEIGHT
     */
    public static final Float WEIGHT_EXTRABOLD =
        Float.valueOf(2.5f);

    
The heaviest predefined weight.

See Also:
  • WEIGHT
/**
     * 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
Number. The default value is WIDTH_REGULAR. 
Several constant values are provided, see WIDTH_CONDENSED, WIDTH_SEMI_CONDENSED, WIDTH_REGULAR, WIDTH_SEMI_EXTENDED, WIDTH_EXTENDED. 
The value is roughly the ratio of the advance width to that
of the regular width.

The system can interpolate the provided value.

/**
     * 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 Also:
  • WIDTH
/**
     * The most condensed predefined width.
     * @see #WIDTH
     */
    public static final Float WIDTH_CONDENSED =
        Float.valueOf(0.75f);

    
A moderately condensed width.

See Also:
  • WIDTH
/**
     * 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 WIDTH. 
See Also:
/**
     * 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 Also:
  • WIDTH
/**
     * A moderately extended width.
     * @see #WIDTH
     */
    public static final Float WIDTH_SEMI_EXTENDED =
        Float.valueOf(1.25f);

    
The most extended predefined width.

See Also:
  • WIDTH
/**
     * 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 Number. The default value is POSTURE_REGULAR. 
Two constant values are provided, POSTURE_REGULAR and POSTURE_OBLIQUE. The value POSTURE_OBLIQUE corresponds to the style value Font.ITALIC as passed to the Font constructor. 
The value is roughly the slope of the stems of the font,
expressed as the run over the rise.  Positive values lean right.

The system can interpolate the provided value.

This will affect the font's italic angle as returned by Font.getItalicAngle. 
See Also:
/**
     * 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 POSTURE. 
See Also:
/**
     * 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 Also:
  • POSTURE
/**
     * 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
Number.  The default value is 12pt.

This corresponds to the size parameter to the Font constructor. 
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.

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.

/**
     * 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 TransformAttribute. The default value is TransformAttribute.IDENTITY. 
The TransformAttribute class defines the constant IDENTITY. 
This corresponds to the transform passed to Font.deriveFont(AffineTransform). Since that transform is mutable and TextAttribute values must not be, the TransformAttribute wrapper class is used. 
The primary intent is to support scaling and skewing, though
other effects are possible.


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.


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 TextLayout.getLayoutPath.


See Also:
/**
     * 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 Integer.  The default value is
0, which means that no superscript or subscript is used.

Two constant values are provided, see SUPERSCRIPT_SUPER and 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. 
SUPERSCRIPT can impact the ascent and descent of a font. The ascent and descent can never become negative, however. 
/**
     * 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 Also:
  • SUPERSCRIPT
/**
     * Standard superscript.
     * @see #SUPERSCRIPT
     */
    public static final Integer SUPERSCRIPT_SUPER =
        Integer.valueOf(1);

    
Standard subscript.

See Also:
  • SUPERSCRIPT
/**
     * 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 Font. The default value is null, indicating that normal resolution of a Font from attributes should be performed. 
TextLayout and AttributedCharacterIterator work in terms of Maps of TextAttributes. Normally, all the attributes are examined and used to select and configure a Font instance. If a FONT attribute is present, though, its associated Font will be used. This provides a way for users to override the resolution of font attributes into a Font, or force use of a particular Font instance. This also allows users to specify subclasses of Font in cases where a Font can be subclassed. 
FONT is used for special situations where clients already have a Font instance but still need to use Map-based APIs. Typically, there will be no other attributes in the Map except the FONT attribute. With Map-based APIs the common case is to specify all attributes individually, so FONT is not needed or desirable. 
However, if both FONT and other attributes are present in the Map, the rendering system will merge the attributes defined in the Font with the additional attributes. This merging process classifies TextAttributes into two groups. One group, the 'primary' group, is considered fundamental to the selection and metric behavior of a font. These attributes are FAMILY, WEIGHT, WIDTH, POSTURE, SIZE, TRANSFORM, SUPERSCRIPT, and TRACKING. The other group, the 'secondary' group, consists of all other defined attributes, with the exception of FONT itself. 
To generate the new Map, first the Font is obtained from the FONT attribute, and all of its attributes extracted into a new Map. Then only the secondary attributes from the original Map are added to those in the new Map. Thus the values of primary attributes come solely from the Font, and the values of secondary attributes originate with the Font but can be overridden by other values in the Map. 
Note:Font's Map-based constructor and deriveFont methods do not process the FONT attribute, as these are used to create new Font objects. Instead, Font.getFont(Map) should be used to handle the FONT attribute. 
See Also:
/**
     * 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.

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 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 \uFFFC.

The GraphicAttribute determines the logical and visual
bounds of the text; the actual Font values are ignored.

See Also:
/**
     * 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>&#92;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 Paint. The default value is null, indicating that the Paint set on the Graphics2D at the time of rendering is used. 
Glyphs will be rendered using this Paint regardless of the Paint value set on the Graphics (but see SWAP_COLORS). 
See Also:
/**
     * 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 Paint.
The default value is null, indicating that the background
should not be rendered.

The logical bounds of the text will be filled using this Paint, and then the text will be rendered on top of it (but see SWAP_COLORS). 
The visual bounds of the text is extended to include the
logical bounds, if necessary.  The outline is not affected.

See Also:
/**
     * 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
Integer.  The default value is -1, which
means no underline.

The constant value UNDERLINE_ON is provided. 
The underline affects both the visual bounds and the outline
of the text.

/**
     * 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 Also:
  • UNDERLINE
/**
     * Standard underline.
     *
     * @see #UNDERLINE
     */
    public static final Integer UNDERLINE_ON =
        Integer.valueOf(0);

    
Attribute key for strikethrough.  Values are instances of
Boolean. The default value is false, which means no strikethrough. 
The constant value STRIKETHROUGH_ON is provided. 
The strikethrough affects both the visual bounds and the
outline of the text.

/**
     * 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 Also:
  • 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 Boolean. The default value is null, which indicates that the standard Bidi algorithm for determining run direction should be used with the value Bidi.DIRECTION_DEFAULT_LEFT_TO_RIGHT. 
The constants RUN_DIRECTION_RTL and RUN_DIRECTION_LTR are provided. 
This determines the value passed to the Bidi constructor to select the primary direction of the text in the paragraph. 
Note: This attribute should have the same value for
all the text in a paragraph, otherwise the behavior is
undetermined.

See Also:
/**
     * 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 Also:
  • 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 Also:
  • RUN_DIRECTION
/**
     * 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 Integer. The default value is null, indicating that the Bidirectional algorithm should run without explicit embeddings. 
Positive values 1 through 61 are embedding levels,
negative values -1 through -61 are override levels. The value 0 means that the base line direction is used. These levels are passed in the embedding levels array to the Bidi constructor. 
Note: 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 Also:
/**
     * 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 Number.  The default value is
1, indicating that justification should use the full width
provided.  Values are pinned to the range [0..1].

The constants JUSTIFICATION_FULL and JUSTIFICATION_NONE are provided. 
Specifies the fraction of the extra space to use when justification is requested on a 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. 
Note: This should have the same value for all the
text in a paragraph, otherwise the behavior is undetermined.

See Also:
/**
     * 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 JUSTIFICATION. 
See Also:
/**
     * 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 Also:
  • JUSTIFICATION
/**
     * 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.

Values are instances of InputMethodHighlight or Annotation. The default value is null, which means that input method styles should not be applied before rendering. 
If adjacent runs of text with the same InputMethodHighlight need to be rendered separately, the InputMethodHighlights should be wrapped in Annotation instances. 
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 Also:
/**
     * 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 Integer. The default value is -1, which means no underline. 
Several constant values are provided, see UNDERLINE_LOW_ONE_PIXEL, UNDERLINE_LOW_TWO_PIXEL, UNDERLINE_LOW_DOTTED, UNDERLINE_LOW_GRAY, and UNDERLINE_LOW_DASHED. 
This may be used in conjunction with UNDERLINE if desired. The primary purpose is for use by input methods. Other use of these underlines for simple ornamentation might confuse users. 
The input method underline affects both the visual bounds and
the outline of the text.

Since:1.3
/**
     * 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 Also:
  • INPUT_METHOD_UNDERLINE
Since:1.3
/**
     * 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 Also:
  • INPUT_METHOD_UNDERLINE
Since:1.3
/**
     * 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 Also:
  • INPUT_METHOD_UNDERLINE
Since:1.3
/**
     * 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 Also:
  • INPUT_METHOD_UNDERLINE
Since:1.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 Also:
  • INPUT_METHOD_UNDERLINE
Since:1.3
/**
     * 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 Paints. Values are instances of Boolean. The default value is false, which means do not swap colors. 
The constant value SWAP_COLORS_ON is defined. 
If the FOREGROUND attribute is set, its Paint will be used as the background, otherwise the Paint currently on the Graphics will be used. If the BACKGROUND attribute is set, its 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 Also:
/**
     * 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 Also:
  • SWAP_COLORS
Since:1.3
/**
     * 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 NumericShaper. The default is null, which means do not perform numeric shaping. 
When a numeric shaper is defined, the text is first
processed by the shaper before any other analysis of the text
is performed.

Note: This should have the same value for all the
text in the paragraph, otherwise the behavior is undetermined.

See Also:
Since:1.4
/**
     * 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
Integer. The default value is 0, which does not request kerning. 
The constant value KERNING_ON is provided. 
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
/**
     * 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 Also:
  • KERNING
Since:1.6
/**
     * 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 Integer. The default value is 0, which means do not use optional ligatures. 
The constant value LIGATURES_ON is defined. 
Ligatures required by the writing system are always enabled.

Since:1.6
/**
     * 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 Also:
  • LIGATURES
Since:1.6
/**
     * 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
Number. The default value is 0, which means no additional tracking. 
The constant values TRACKING_TIGHT and TRACKING_LOOSE are provided. 
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 -0.1 and 0.3; values outside this range are generally not desirable. 
Since:1.6
/**
     * 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 Also:
  • TRACKING
Since:1.6
/**
     * Perform tight tracking.
     * @see #TRACKING
     * @since 1.6
     */
    public static final Float TRACKING_TIGHT =
        Float.valueOf(-.04f);

    
Perform loose tracking.

See Also:
  • TRACKING
Since:1.6
/**
     * Perform loose tracking.
     * @see #TRACKING
     * @since 1.6
     */
    public static final Float TRACKING_LOOSE =
        Float.valueOf(.04f);
}