GlyphVector object is a collection of glyphs
containing geometric information for the placement of each glyph
in a transformed coordinate space which corresponds to the
device on which the GlyphVector is ultimately
displayed.
The GlyphVector does not attempt any interpretation of
the sequence of glyphs it contains. Relationships between adjacent
glyphs in sequence are solely used to determine the placement of
the glyphs in the visual coordinate space.
Instances of GlyphVector are created by a Font
.
In a text processing application that can cache intermediate
representations of text, creation and subsequent caching of a
GlyphVector for use during rendering is the fastest
method to present the visual representation of characters to a user.
A GlyphVector is associated with exactly one
Font, and can provide data useful only in relation to
this Font. In addition, metrics obtained from a
GlyphVector are not generally geometrically scaleable
since the pixelization and spacing are dependent on grid-fitting
algorithms within a Font. To facilitate accurate
measurement of a GlyphVector and its component
glyphs, you must specify a scaling transform, anti-alias mode, and
fractional metrics mode when creating the GlyphVector.
These characteristics can be derived from the destination device.
For each glyph in the GlyphVector, you can obtain:
GlyphVector. The metrics of the glyph may be
different under different transforms, application specified
rendering hints, and the specific instance of the glyph within
the GlyphVector.
Altering the data used to create the GlyphVector does not
alter the state of the GlyphVector.
Methods are provided to adjust the positions of the glyphs
within the GlyphVector. These methods are most
appropriate for applications that are performing justification
operations for the presentation of the glyphs.
Methods are provided to transform individual glyphs within the
GlyphVector. These methods are primarily useful for
special effects.
Methods are provided to return both the visual, logical, and pixel bounds
of the entire GlyphVector or of individual glyphs within
the GlyphVector.
Methods are provided to return a Shape
for the
GlyphVector, and for individual glyphs within the
GlyphVector.
GlyphVector has
a complex glyph-to-char mapping (one that does not map glyphs to chars one-to-one in
strictly ascending or descending order matching the run direction).GlyphVector has
position adjustments. When this is true, the glyph positions don't match the
accumulated default advances of the glyphs (for example, if kerning has been done).GlyphVector has
per-glyph transforms.GlyphVector has
a right-to-left run direction. This refers to the glyph-to-char mapping and does
not imply that the visual locations of the glyphs are necessarily in this order,
although generally they will be.GlyphVector exactly
equals this GlyphVector.
The equals method implements an equivalence relation
on non-null object references:
x, x.equals(x) should return
true.
x and y, x.equals(y)
should return true if and only if
y.equals(x) returns true.
x, y, and z, if
x.equals(y) returns true and
y.equals(z) returns true, then
x.equals(z) should return true.
x and y, multiple invocations of
x.equals(y) consistently return true
or consistently return false, provided no
information used in equals comparisons on the
objects is modified.
x,
x.equals(null) should return false.
The equals method for class Object implements
the most discriminating possible equivalence relation on objects;
that is, for any non-null reference values x and
y, this method returns true if and only
if x and y refer to the same object
(x == y has the value true).
Note that it is generally necessary to override the hashCode method whenever this method is overridden, so as to maintain the general contract for the hashCode method, which states that equal objects must have equal hash codes.
Font associated with this
GlyphVector.GlyphVector.Font object that created this
GlyphVector.Font used to create this
GlyphVector. This method is used
for convenience and performance when processing glyphcodes.
If no array is passed in, a new array is created.GlyphVector.GlyphVector.
These logical bounds have a total of four edges, with two edges
parallel to the baseline under the glyph's transform and the other two
edges are shared with adjacent glyphs if they are present. This
method is useful for hit-testing of the specified glyph,
positioning of a caret at the leading or trailing edge of a glyph,
and for drawing a highlight region around the specified glyph.GlyphVector.Shape whose interior corresponds to the
visual representation of the specified glyph
within this GlyphVector.
The outline returned by this method is positioned around the
origin of each individual glyph.Shape whose interior corresponds to the
visual representation of the specified glyph
within this GlyphVector, offset to x, y.
The outline returned by this method is positioned around the
origin of each individual glyph.GlyphVector is rendered in a Graphics with the
given FontRenderContext at the given location. The
renderFRC need not be the same as the
FontRenderContext of this
GlyphVector, and can be null. If it is null, the
FontRenderContext of this GlyphVector
is used. The default implementation returns the visual bounds of the glyph,
offset to x, y and rounded out to the next integer value, and
ignores the FRC. Subclassers should override this method.GlyphVector.
If glyphIndex equals the number of of glyphs in
this GlyphVector, this method returns the position after
the last glyph. This position is used to define the advance of
the entire GlyphVector.beginGlyphIndex + position/2.
Odd numbered array entries beginning with position one are the Y
coordinates of the glyph numbered beginGlyphIndex + (position-1)/2.
If beginGlyphIndex equals the number of of glyphs in
this GlyphVector, this method gets the position after
the last glyph and this position is used to define the advance of
the entire GlyphVector.GlyphVector. The transform is relative to the
glyph position. If no special transform has been applied,
null can be returned. A null return indicates
an identity transform.GlyphVector.
The bounds returned by this method is positioned around the
origin of each individual glyph.GlyphVector.
This method is used when positioning this GlyphVector
in relation to visually adjacent GlyphVector objects.GlyphVector.Shape whose interior corresponds to the
visual representation of this GlyphVector.Shape whose interior corresponds to the
visual representation of this GlyphVector when
rendered at x, y.GlyphVector when
rendered in a graphics with the given
FontRenderContext at the given location. The
renderFRC need not be the same as the
FontRenderContext of this
GlyphVector, and can be null. If it is null, the
FontRenderContext of this GlyphVector
is used. The default implementation returns the visual bounds,
offset to x, y and rounded out to the next integer value (i.e. returns an
integer rectangle which encloses the visual bounds) and
ignores the FRC. Subclassers should override this method.GlyphVector
The visual bounds is the bounding box of the outline of this
GlyphVector. Because of rasterization and
alignment of pixels, it is possible that this box does not
enclose all pixels affected by rendering this GlyphVector.java.util.Hashtable.
The general contract of hashCode is:
hashCode method on each of
the two objects must produce the same integer result.
As much as is reasonably practical, the hashCode method defined by class Object does return distinct integers for distinct objects. (This is typically implemented by converting the internal address of the object into an integer, but this implementation technique is not required by the JavaTM programming language.)
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.
GlyphVector. This can destroy information
generated during initial layout of this GlyphVector.GlyphVector.
If glyphIndex equals the number of of glyphs in
this GlyphVector, this method sets the position after
the last glyph. This position is used to define the advance of
the entire GlyphVector.GlyphVector. The transform is relative to the glyph
position. A null argument for newTX
indicates that no special transform is applied for the specified
glyph.
This method can be used to rotate, mirror, translate and scale the
glyph. Adding a transform can result in signifant performance changes.toString method returns a string that
"textually represents" this object. The result should
be a concise but informative representation that is easy for a
person to read.
It is recommended that all subclasses override this method.
The toString method for class Object
returns a string consisting of the name of the class of which the
object is an instance, the at-sign character `@', and
the unsigned hexadecimal representation of the hash code of the
object. In other words, this method returns a string equal to the
value of:
getClass().getName() + '@' + Integer.toHexString(hashCode())
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.