TextAttribute class defines attribute keys and
attribute values used for text rendering.
TextAttribute instances are used as attribute keys to
identify attributes in
AttributedCharacterIterator
,
Font
, and other classes handling text
attributes. Other constants defined in this class are used
as attribute values.
For each text attribute, the documentation describes:
null value).
null or not of the proper type
then it has the default effect. The effect of a particular value
can be interpolated, especially in the case of multiple master
fonts. This interpolation is done based on the nearest defined
constants above and below the request:interpolation = (request - below)/(above - below);
Key |
BACKGROUND |
|---|---|
Value |
Paint |
Default |
null |
Description |
Specify the background Paint (or Color) of the text. |
Key |
BIDI_EMBEDDING |
|---|---|
Value |
Integer |
Limits |
Positive values 1 through 61 are embedding
levels, negative values through -61 are override levels |
Default |
Use standard BIDI to compute levels from formatting characters in the text. |
Description |
Specifies the bidi embedding level of the character. When this attribute is present anywhere in a paragraph, then the Unicode characters RLO, LRO, RLE, LRE, PDF are disregarded in the BIDI analysis of that paragraph. See the Unicode Standard v. 2.0, section 3-11. |
Key |
CHAR_REPLACEMENT |
|---|---|
Value |
GraphicAttribute |
Description |
Allows the user to specify an empty position plus
metric information. This method is used to reserve space for a graphic
or other embedded component. Required for
correct BIDI position of 'inline' components within a line. An optional
convenience method allows drawing for simple cases. Follows the
Microsoft model: the character that this is applied to should be
\uFFFC. |
Key |
FAMILY |
|---|---|
Value |
String |
Constants |
"Serif", "SansSerif" |
Default |
Host default; |
Description |
The name of the font family. If the family name is not found, the default font is used. The name should not be the full font name or specify other attributes (such as the name "Helvetica Bold"). Such names might result in the default font if the name does not match a known family name. |
Key |
FONT |
|---|---|
Value |
Font |
Default |
None, perform default resolution |
Description |
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. |
Key |
FOREGROUND |
|---|---|
Value |
Paint |
Default |
Color.black |
Description |
Specify the foreground Paint (or Color) of the text. |
Values are instances of InputMethodHighlight . These instances should be wrapped in Annotation instances if segments need to be highlighted separately.
Input method highlights are used while text is being composed using 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.
Values are instances of Annotation holding a null reference.
Key |
INPUT_METHOD_UNDERLINE |
|---|---|
Value |
Integer |
Constants |
UNDERLINE_LOW_ONE_PIXEL, UNDERLINE_LOW_TWO_PIXEL, UNDERLINE_LOW_DOTTED, UNDERLINE_LOW_GRAY, UNDERLINE_LOW_DASHED |
Default |
no underline |
Key |
JUSTIFICATION |
|---|---|
Value |
Float |
Limits |
0.0 through1.0 |
Default |
1.0 |
Description |
Specifies which fraction of the extra space to use when justification is requested. For example, if the line is 50 points wide and the margins are 70 points apart, a value of 0.5 means that the line is padded to reach a width of 60 points. This attribute should have the same value over the whole paragraph. |
Values are instances of Locale.
Values are instances of NumericShaping.
The default is not to perform numeric shaping.
Key |
POSTURE |
|---|---|
Value |
Float |
Constants |
POSTURE_REGULAR = 0, POSTURE_OBLIQUE = 0.20 |
Default |
POSTURE_REGULAR |
Description |
The value is interpreted generally as a skew slope,
positive leans to the right. If the font has a different value for
specific constants, then the value is interpolated as described in
the class description. With fonts that have italic faces, not only
the skew of the character changes, but also the letter shapes
might change. Notes: To set the value by angle, use: value = new Float(Math.tan(Math.PI*degrees/180.0) To determine the angle from the value, use: angle = Math.atan(value.floatValue())*180/Math.PI |
Fallback |
If an Oblique font is available and matches, use that. Otherwise skew with a transform using the posture value interpreted as run/rise. |
Values are instances of Annotation holding instances of String.
Key |
RUN_DIRECTION |
|---|---|
Value |
Boolean |
Constants |
RUN_DIRECTION_LTR = true, RUN_DIRECTION_RTL = false |
Default |
Use the default Unicode base direction from the BIDI algorithm. |
Description |
Specifies which base run direction to use when
positioning mixed directional runs within a paragraph. If this value is
RUN_DIRECTION_DEFAULT, This attribute should have the same value over the whole paragraph. |
Key |
SIZE |
|---|---|
Value |
Float |
Default |
from System Properties |
Description |
Represents point 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. |
Fallback |
Scale to provided size. |
Key |
STRIKETHROUGH |
|---|---|
Value |
Boolean |
Constants |
true = on, false = off |
Default |
off |
Description |
An embellishment added to the glyphs rendered by a font. |
Key |
SUPERSCRIPT |
|---|---|
Value |
Integer |
Constants |
SUPERSCRIPT_NONE = 0, SUPERSCRIPT_SUPER = 1, SUPERSCRIPT_SUB = -1 |
Default |
SUPERSCRIPT_NONE |
Description |
Requests that the font display the characters with glyphs at a particular superscript level: 0 = none, 1 = superscript, 2 = superscript of superscript,...-1 = subscript, -2 = subscript of subscript,... Requests that the font display text using default superscript (or subscript) glyphs and/or scaling. |
Fallback |
Use transform with translation of +/-1/2 and scale
of 2/3, progressively for each level. That is, for the transform at
level N (with N != 0): offset = sign(N)*1/2*(2/3)^(abs(N)-1) scale = (2/3)^abs(N) |
Values are instances of Boolean.
The default is not to swap the foreground and background.
If the foreground and background attributes are both defined,
this causes them to be swapped when rendering text. If either is
defaulted, the exact effect is undefined--generally it will produce
an 'inverted' appearance.
Key |
TRANSFORM |
|---|---|
Value |
TransformAttribute |
Default |
Identity transform |
Description |
Used to transform glyphs rendered by this font. The primary intent is to support scaling, skewing, and translation. In general, large rotations do not produce very useful results. The transform modifies both the glyph and the advance. The translations in the transform are interpreted as a ratio of the point size. That is, with a point size of 12, a translation of 0.5 results in a movement of 6 points. The advance point of the transformed glyph is the transform of the advance point projected onto the baseline. If the advance ends up to the left (top) of the glyph origin, the two points are swapped.
Example one: The point size is 20, the original advance is 10.0, and the transform is a 60 degree counterclockwise rotation plus an offset up and to the right of 0.1, -0.1. The translation results in an offset of <2.0, -2.0>. The original advance point is <10.0, 0.0>; after the rotation it is <6.0, -8.0>; when adding the offset this becomes <8.0,-10.0>, when projecting on the (horizontal) baseline this becomes the new advance point: <8.0, 0.0>. The advance width is the distance from the origin to the advance point: 8.0. The rotated glyph is rendered two points up and to the right of its origin and rotated. This does not affect the baseline for subsequent glyphs. |
Key |
UNDERLINE |
|---|---|
Value |
Integer |
Constants |
UNDERLINE_ON = 0 |
Default |
none |
Description |
An embellishment added to the glyphs rendered by a font. |
Fallback |
Key |
WEIGHT |
|---|---|
Value |
Float |
Constants |
WEIGHT_EXTRA_LIGHT = 0.5, WEIGHT_LIGHT = 0.75, WEIGHT_DEMILIGHT = 0.875, WEIGHT_REGULAR = 1.0, WEIGHT_SEMIBOLD = 1.25, WEIGHT_MEDIUM = 1.5, WEIGHT_DEMIBOLD = 1.75, WEIGHT_BOLD = 2.0, WEIGHT_HEAVY = 2.25, WEIGHT_EXTRABOLD = 2.5, WEIGHT_ULTRABOLD = 2.75 |
Default |
WEIGHT_REGULAR |
Description |
The value is roughly the ratio of the stem width to that of the regular weight. If the font has a different value for specific constants, then the value is interpolated as described in the class description. |
Fallback |
Currently none. However, in the future, shape
manipulations might be available to simulate weight variations for fonts that don't have them. |
Key |
WIDTH |
|---|---|
Value |
Float |
Constants |
WIDTH_CONDENSED = 0.75, WIDTH_SEMI_CONDENSED = 0.875, WIDTH_REGULAR = 1.0, WIDTH_SEMI_EXTENDED = 1.25, WIDTH_EXTENDED = 1.5 |
Default |
WIDTH_REGULAR |
Description |
The value is roughly the ratio of the advance width to that of the regular width. If the font has a different value for specific constants, then the value is interpolated as described in the class description. |
Fallback |
If a Narrow font is available and matches, use that. Otherwise scale with a transform based on the value. |
x.equals(y) if x and y refer
to the same object, and guarantees this for all subclasses.wait methods.
The awakened thread will not be able to proceed until the current thread relinquishes the lock on this object. The awakened thread will compete in the usual manner with any other threads that might be actively competing to synchronize on this object; for example, the awakened thread enjoys no reliable privilege or disadvantage in being the next thread to lock this object.
This method should only be called by a thread that is the owner of this object's monitor. A thread becomes the owner of the object's monitor in one of three ways:
synchronized statement
that synchronizes on the object.
Class, by executing a
synchronized static method of that class.
Only one thread at a time can own an object's monitor.
wait methods.
The awakened threads will not be able to proceed until the current thread relinquishes the lock on this object. The awakened threads will compete in the usual manner with any other threads that might be actively competing to synchronize on this object; for example, the awakened threads enjoy no reliable privilege or disadvantage in being the next thread to lock this object.
This method should only be called by a thread that is the owner
of this object's monitor. See the notify method for a
description of the ways in which a thread can become the owner of
a monitor.
The current thread must own this object's monitor. The thread
releases ownership of this monitor and waits until another thread
notifies threads waiting on this object's monitor to wake up
either through a call to the notify method or the
notifyAll method. The thread then waits until it can
re-obtain ownership of the monitor and resumes execution.
As in the one argument version, interrupts and spurious wakeups are possible, and this method should always be used in a loop:
synchronized (obj) {
while (<condition does not hold>)
obj.wait();
... // Perform action appropriate to condition
}
This method should only be called by a thread that is the owner
of this object's monitor. See the notify method for a
description of the ways in which a thread can become the owner of
a monitor.The current thread must own this object's monitor.
This method causes the current thread (call it T) to place itself in the wait set for this object and then to relinquish any and all synchronization claims on this object. Thread T becomes disabled for thread scheduling purposes and lies dormant until one of four things happens:
A thread can also wake up without being notified, interrupted, or timing out, a so-called spurious wakeup. While this will rarely occur in practice, applications must guard against it by testing for the condition that should have caused the thread to be awakened, and continuing to wait if the condition is not satisfied. In other words, waits should always occur in loops, like this one:
synchronized (obj) {
while (<condition does not hold>)
obj.wait(timeout);
... // Perform action appropriate to condition
}
(For more information on this topic, see Section 3.2.3 in Doug Lea's
"Concurrent Programming in Java (Second Edition)" (Addison-Wesley,
2000), or Item 50 in Joshua Bloch's "Effective Java Programming
Language Guide" (Addison-Wesley, 2001).
If the current thread is interrupted by another thread while it is waiting, then an InterruptedException is thrown. This exception is not thrown until the lock status of this object has been restored as described above.
Note that the wait method, as it places the current thread into the wait set for this object, unlocks only this object; any other objects on which the current thread may be synchronized remain locked while the thread waits.
This method should only be called by a thread that is the owner
of this object's monitor. See the notify method for a
description of the ways in which a thread can become the owner of
a monitor.
This method is similar to the wait method of one
argument, but it allows finer control over the amount of time to
wait for a notification before giving up. The amount of real time,
measured in nanoseconds, is given by:
1000000*timeout+nanos
In all other respects, this method does the same thing as the method of one argument. In particular, wait(0, 0) means the same thing as wait(0).
The current thread must own this object's monitor. The thread releases ownership of this monitor and waits until either of the following two conditions has occurred:
notify method
or the notifyAll method.
timeout
milliseconds plus nanos nanoseconds arguments, has
elapsed.
The thread then waits until it can re-obtain ownership of the monitor and resumes execution.
As in the one argument version, interrupts and spurious wakeups are possible, and this method should always be used in a loop:
synchronized (obj) {
while (<condition does not hold>)
obj.wait(timeout, nanos);
... // Perform action appropriate to condition
}
This method should only be called by a thread that is the owner
of this object's monitor. See the notify method for a
description of the ways in which a thread can become the owner of
a monitor.