WrappedPlainView.java

/*
 * Copyright (c) 1998, 2024, 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.
 */
packagejavax.swing.text;

importjava.awt.*;
importjava.awt.font.FontRenderContext;
importjava.awt.geom.Rectangle2D;
importjava.lang.ref.SoftReference;
importjavax.swing.event.*;
importstaticjavax.swing.text.PlainView.FPMethodArgs.*;
importstaticjavax.swing.text.PlainView.getFPMethodOverridden;

/**
 * View of plain text (text with only one font and color)
 * that does line-wrapping. This view expects that its
 * associated element has child elements that represent
 * the lines it should be wrapping. It is implemented
 * as a vertical box that contains logical line views.
 * The logical line views are nested classes that render
 * the logical line as multiple physical line if the logical
 * line is too wide to fit within the allocation. The
 * line views draw upon the outer class for its state
 * to reduce their memory requirements.
 * <p>
 * The line views do all of their rendering through the
 * <code>drawLine</code> method which in turn does all of
 * its rendering through the <code>drawSelectedText</code>
 * and <code>drawUnselectedText</code> methods. This
 * enables subclasses to easily specialize the rendering
 * without concern for the layout aspects.
 *
 * @author Timothy Prinzing
 * @see View
 */
publicclassWrappedPlainViewextendsBoxViewimplementsTabExpander {

/**
 * Creates a new WrappedPlainView. Lines will be wrapped
 * on character boundaries.
 *
 * @param elem the element underlying the view
 */
publicWrappedPlainView(Elementelem) {
this(elem, false);
 }

/**
 * Creates a new WrappedPlainView. Lines can be wrapped on
 * either character or word boundaries depending upon the
 * setting of the wordWrap parameter.
 *
 * @param elem the element underlying the view
 * @param wordWrap should lines be wrapped on word boundaries?
 */
publicWrappedPlainView(Elementelem, booleanwordWrap) {
super(elem, Y_AXIS);
this.wordWrap = wordWrap;
 }

/**
 * Returns the tab size set for the document, defaulting to 8.
 *
 * @return the tab size
 */
protectedintgetTabSize() {
Integeri = (Integer) getDocument().getProperty(PlainDocument.tabSizeAttribute);
intsize = (i != null) ? i.intValue() : 8;
returnsize;
 }

/**
 * Renders a line of text, suppressing whitespace at the end
 * and expanding any tabs. This is implemented to make calls
 * to the methods <code>drawUnselectedText</code> and
 * <code>drawSelectedText</code> so that the way selected and
 * unselected text are rendered can be customized.
 *
 * @param p0 the starting document location to use &gt;= 0
 * @param p1 the ending document location to use &gt;= p1
 * @param g the graphics context
 * @param x the starting X position &gt;= 0
 * @param y the starting Y position &gt;= 0
 * @see #drawUnselectedText
 * @see #drawSelectedText
 *
 * @deprecated replaced by
 * {@link #drawLine(int, int, Graphics2D, float, float)}
 */
@Deprecated(since = "9")
protectedvoiddrawLine(intp0, intp1, Graphicsg, intx, inty) {
drawLineImpl(p0, p1, g, x, y, false);
 }

privatevoiddrawLineImpl(intp0, intp1, Graphicsg, floatx, floaty,
booleanuseFPAPI) {
ElementlineMap = getElement();
Elementline = lineMap.getElement(lineMap.getElementIndex(p0));
Elementelem;

try {
if (line.isLeaf()) {
drawText(line, p0, p1, g, x, y);
 } else {
// this line contains the composed text.
intidx = line.getElementIndex(p0);
intlastIdx = line.getElementIndex(p1);
for(; idx <= lastIdx; idx++) {
elem = line.getElement(idx);
intstart = Math.max(elem.getStartOffset(), p0);
intend = Math.min(elem.getEndOffset(), p1);
x = drawText(elem, start, end, g, x, y);
 }
 }
 } catch (BadLocationExceptione) {
thrownewStateInvariantError("Can't render: " + p0 + "," + p1);
 }
 }

/**
 * Renders a line of text, suppressing whitespace at the end
 * and expanding any tabs. This is implemented to make calls
 * to the methods <code>drawUnselectedText</code> and
 * <code>drawSelectedText</code> so that the way selected and
 * unselected text are rendered can be customized.
 *
 * @param p0 the starting document location to use &gt;= 0
 * @param p1 the ending document location to use &gt;= p1
 * @param g the graphics context
 * @param x the starting X position &gt;= 0
 * @param y the starting Y position &gt;= 0
 * @see #drawUnselectedText
 * @see #drawSelectedText
 *
 * @since 9
 */
protectedvoiddrawLine(intp0, intp1, Graphics2Dg, floatx, floaty) {
drawLineImpl(p0, p1, g, x, y, true);
 }

privatefloatdrawText(Elementelem, intp0, intp1, Graphicsg,
floatx, floaty)
throwsBadLocationException
 {
p1 = Math.min(getDocument().getLength(), p1);
AttributeSetattr = elem.getAttributes();

if (Utilities.isComposedTextAttributeDefined(attr)) {
g.setColor(unselected);
x = Utilities.drawComposedText(this, attr, g, x, y,
p0-elem.getStartOffset(),
p1-elem.getStartOffset());
 } else {
if (sel0 == sel1 || selected == unselected) {
// no selection, or it is invisible
x = callDrawUnselectedText(g, x, y, p0, p1);
 } elseif ((p0 >= sel0 && p0 <= sel1) && (p1 >= sel0 && p1 <= sel1)) {
x = callDrawSelectedText(g, x, y, p0, p1);
 } elseif (sel0 >= p0 && sel0 <= p1) {
if (sel1 >= p0 && sel1 <= p1) {
x = callDrawUnselectedText(g, x, y, p0, sel0);
x = callDrawSelectedText(g, x, y, sel0, sel1);
x = callDrawUnselectedText(g, x, y, sel1, p1);
 } else {
x = callDrawUnselectedText(g, x, y, p0, sel0);
x = callDrawSelectedText(g, x, y, sel0, p1);
 }
 } elseif (sel1 >= p0 && sel1 <= p1) {
x = callDrawSelectedText(g, x, y, p0, sel1);
x = callDrawUnselectedText(g, x, y, sel1, p1);
 } else {
x = callDrawUnselectedText(g, x, y, p0, p1);
 }
 }

returnx;
 }

/**
 * Renders the given range in the model as normal unselected
 * text.
 *
 * @param g the graphics context
 * @param x the starting X coordinate &gt;= 0
 * @param y the starting Y coordinate &gt;= 0
 * @param p0 the beginning position in the model &gt;= 0
 * @param p1 the ending position in the model &gt;= p0
 * @return the X location of the end of the range &gt;= 0
 * @throws BadLocationException if the range is invalid
 *
 * @deprecated replaced by
 * {@link #drawUnselectedText(Graphics2D, float, float, int, int)}
 */
@Deprecated(since = "9")
protectedintdrawUnselectedText(Graphicsg, intx, inty,
intp0, intp1) throwsBadLocationException
 {
return (int) drawUnselectedTextImpl(g, x, y, p0, p1, false);
 }

privatefloatcallDrawUnselectedText(Graphicsg, floatx, floaty,
intp0, intp1)
throwsBadLocationException
 {
returndrawUnselectedTextOverridden && ginstanceofGraphics2D
 ? drawUnselectedText((Graphics2D) g, x, y, p0, p1)
 : drawUnselectedText(g, (int) x, (int) y, p0, p1);
 }

privatefloatdrawUnselectedTextImpl(Graphicsg, floatx, floaty,
intp0, intp1, booleanuseFPAPI)
throwsBadLocationException
 {
g.setColor(unselected);
Documentdoc = getDocument();
Segmentsegment = SegmentCache.getSharedSegment();
doc.getText(p0, p1 - p0, segment);
floatret = Utilities.drawTabbedText(this, segment, x, y, g, this, p0,
null, useFPAPI);
SegmentCache.releaseSharedSegment(segment);
returnret;
 }

/**
 * Renders the given range in the model as normal unselected
 * text.
 *
 * @param g the graphics context
 * @param x the starting X coordinate &gt;= 0
 * @param y the starting Y coordinate &gt;= 0
 * @param p0 the beginning position in the model &gt;= 0
 * @param p1 the ending position in the model &gt;= p0
 * @return the X location of the end of the range &gt;= 0
 * @throws BadLocationException if the range is invalid
 *
 * @since 9
 */
protectedfloatdrawUnselectedText(Graphics2Dg, floatx, floaty,
intp0, intp1) throwsBadLocationException {
returndrawUnselectedTextImpl(g, x, y, p0, p1, true);
 }
/**
 * Renders the given range in the model as selected text. This
 * is implemented to render the text in the color specified in
 * the hosting component. It assumes the highlighter will render
 * the selected background.
 *
 * @param g the graphics context
 * @param x the starting X coordinate &gt;= 0
 * @param y the starting Y coordinate &gt;= 0
 * @param p0 the beginning position in the model &gt;= 0
 * @param p1 the ending position in the model &gt;= p0
 * @return the location of the end of the range.
 * @throws BadLocationException if the range is invalid
 *
 * @deprecated replaced by
 * {@link #drawSelectedText(Graphics2D, float, float, int, int)}
 */
@Deprecated(since = "9")
protectedintdrawSelectedText(Graphicsg, intx, inty, intp0, intp1)
throwsBadLocationException
 {
return (int) drawSelectedTextImpl(g, x, y, p0, p1, false);
 }

privatefloatcallDrawSelectedText(Graphicsg, floatx, floaty,
intp0, intp1)
throwsBadLocationException
 {
returndrawSelectedTextOverridden && ginstanceofGraphics2D
 ? drawSelectedText((Graphics2D) g, x, y, p0, p1)
 : drawSelectedText(g, (int) x, (int) y, p0, p1);
 }

privatefloatdrawSelectedTextImpl(Graphicsg, floatx, floaty,
intp0, intp1,
booleanuseFPAPI)
throwsBadLocationException
 {
g.setColor(selected);
Documentdoc = getDocument();
Segmentsegment = SegmentCache.getSharedSegment();
doc.getText(p0, p1 - p0, segment);
floatret = Utilities.drawTabbedText(this, segment, x, y, g, this, p0,
null, useFPAPI);
SegmentCache.releaseSharedSegment(segment);
returnret;
 }

/**
 * Renders the given range in the model as selected text. This
 * is implemented to render the text in the color specified in
 * the hosting component. It assumes the highlighter will render
 * the selected background.
 *
 * @param g the graphics context
 * @param x the starting X coordinate &gt;= 0
 * @param y the starting Y coordinate &gt;= 0
 * @param p0 the beginning position in the model &gt;= 0
 * @param p1 the ending position in the model &gt;= p0
 * @return the location of the end of the range.
 * @throws BadLocationException if the range is invalid
 *
 * @since 9
 */
protectedfloatdrawSelectedText(Graphics2Dg, floatx, floaty,
intp0, intp1) throwsBadLocationException {
returndrawSelectedTextImpl(g, x, y, p0, p1, true);
 }
/**
 * Gives access to a buffer that can be used to fetch
 * text from the associated document.
 *
 * @return the buffer
 */
protectedfinalSegmentgetLineBuffer() {
if (lineBuffer == null) {
lineBuffer = newSegment();
 }
returnlineBuffer;
 }

/**
 * This is called by the nested wrapped line
 * views to determine the break location. This can
 * be reimplemented to alter the breaking behavior.
 * It will either break at word or character boundaries
 * depending upon the break argument given at
 * construction.
 * @param p0 the starting document location
 * @param p1 the ending document location to use
 * @return the break position
 */
protectedintcalculateBreakPosition(intp0, intp1) {
intp;
Segmentsegment = SegmentCache.getSharedSegment();
loadText(segment, p0, p1);
intcurrentWidth = getWidth();
if (wordWrap) {
p = p0 + Utilities.getBreakLocation(segment, metrics,
 (float)tabBase,
 (float)(tabBase + currentWidth),
this, p0);
 } else {
p = p0 + Utilities.getTabbedTextOffset(segment, metrics,
 (float)tabBase,
 (float)(tabBase + currentWidth),
this, p0, false);
 }
SegmentCache.releaseSharedSegment(segment);
returnp;
 }

/**
 * Loads all of the children to initialize the view.
 * This is called by the <code>setParent</code> method.
 * Subclasses can reimplement this to initialize their
 * child views in a different manner. The default
 * implementation creates a child view for each
 * child element.
 *
 * @param f the view factory
 */
protectedvoidloadChildren(ViewFactoryf) {
Elemente = getElement();
intn = e.getElementCount();
if (n > 0) {
View[] added = newView[n];
for (inti = 0; i < n; i++) {
added[i] = newWrappedLine(e.getElement(i));
 }
replace(0, 0, added);
 }
 }

/**
 * Update the child views in response to a
 * document event.
 */
voidupdateChildren(DocumentEvente, Shapea) {
Elementelem = getElement();
DocumentEvent.ElementChangeec = e.getChange(elem);
if (ec != null) {
// the structure of this element changed.
Element[] removedElems = ec.getChildrenRemoved();
Element[] addedElems = ec.getChildrenAdded();
View[] added = newView[addedElems.length];
for (inti = 0; i < addedElems.length; i++) {
added[i] = newWrappedLine(addedElems[i]);
 }
replace(ec.getIndex(), removedElems.length, added);

// should damage a little more intelligently.
if (a != null) {
preferenceChanged(null, true, true);
getContainer().repaint();
 }
 }

// update font metrics which may be used by the child views
updateMetrics();
 }

/**
 * Load the text buffer with the given range
 * of text. This is used by the fragments
 * broken off of this view as well as this
 * view itself.
 */
finalvoidloadText(Segmentsegment, intp0, intp1) {
try {
Documentdoc = getDocument();
doc.getText(p0, p1 - p0, segment);
 } catch (BadLocationExceptionbl) {
thrownewStateInvariantError("Can't get line text");
 }
 }

finalvoidupdateMetrics() {
Componenthost = getContainer();
Fontf = host.getFont();
metrics = host.getFontMetrics(f);
if (useFloatingPointAPI) {
FontRenderContextfrc = metrics.getFontRenderContext();
floattabWidth = (float) f.getStringBounds("m", frc).getWidth();
tabSize = getTabSize() * tabWidth;
 } else {
tabSize = getTabSize() * metrics.charWidth('m');
 }
 }

// --- TabExpander methods ------------------------------------------

/**
 * Returns the next tab stop position after a given reference position.
 * This implementation does not support things like centering so it
 * ignores the tabOffset argument.
 *
 * @param x the current position &gt;= 0
 * @param tabOffset the position within the text stream
 * that the tab occurred at &gt;= 0.
 * @return the tab stop, measured in points &gt;= 0
 */
publicfloatnextTabStop(floatx, inttabOffset) {
if (tabSize == 0)
returnx;
intntabs = (int) ((x - tabBase) / tabSize);
returntabBase + ((ntabs + 1) * tabSize);
 }


// --- View methods -------------------------------------

/**
 * Renders using the given rendering surface and area
 * on that surface. This is implemented to stash the
 * selection positions, selection colors, and font
 * metrics for the nested lines to use.
 *
 * @param g the rendering surface to use
 * @param a the allocated region to render into
 *
 * @see View#paint
 */
publicvoidpaint(Graphicsg, Shapea) {
Rectanglealloc = (Rectangle) a;
tabBase = alloc.x;
JTextComponenthost = (JTextComponent) getContainer();
sel0 = host.getSelectionStart();
sel1 = host.getSelectionEnd();
unselected = (host.isEnabled()) ?
host.getForeground() : host.getDisabledTextColor();
Caretc = host.getCaret();
selected = c.isSelectionVisible() && host.getHighlighter() != null ?
host.getSelectedTextColor() : unselected;
g.setFont(host.getFont());

// superclass paints the children
super.paint(g, a);
 }

/**
 * Sets the size of the view. This should cause
 * layout of the view along the given axis, if it
 * has any layout duties.
 *
 * @param width the width &gt;= 0
 * @param height the height &gt;= 0
 */
publicvoidsetSize(floatwidth, floatheight) {
updateMetrics();
if ((int) width != getWidth()) {
// invalidate the view itself since the desired widths
// of the children will be based upon this views width.
preferenceChanged(null, true, true);
widthChanging = true;
 }
super.setSize(width, height);
widthChanging = false;
 }

/**
 * Determines the preferred span for this view along an
 * axis. This is implemented to provide the superclass
 * behavior after first making sure that the current font
 * metrics are cached (for the nested lines which use
 * the metrics to determine the height of the potentially
 * wrapped lines).
 *
 * @param axis may be either View.X_AXIS or View.Y_AXIS
 * @return the span the view would like to be rendered into.
 * Typically the view is told to render into the span
 * that is returned, although there is no guarantee.
 * The parent may choose to resize or break the view.
 * @see View#getPreferredSpan
 */
publicfloatgetPreferredSpan(intaxis) {
updateMetrics();
returnsuper.getPreferredSpan(axis);
 }

/**
 * Determines the minimum span for this view along an
 * axis. This is implemented to provide the superclass
 * behavior after first making sure that the current font
 * metrics are cached (for the nested lines which use
 * the metrics to determine the height of the potentially
 * wrapped lines).
 *
 * @param axis may be either View.X_AXIS or View.Y_AXIS
 * @return the span the view would like to be rendered into.
 * Typically the view is told to render into the span
 * that is returned, although there is no guarantee.
 * The parent may choose to resize or break the view.
 * @see View#getMinimumSpan
 */
publicfloatgetMinimumSpan(intaxis) {
updateMetrics();
returnsuper.getMinimumSpan(axis);
 }

/**
 * Determines the maximum span for this view along an
 * axis. This is implemented to provide the superclass
 * behavior after first making sure that the current font
 * metrics are cached (for the nested lines which use
 * the metrics to determine the height of the potentially
 * wrapped lines).
 *
 * @param axis may be either View.X_AXIS or View.Y_AXIS
 * @return the span the view would like to be rendered into.
 * Typically the view is told to render into the span
 * that is returned, although there is no guarantee.
 * The parent may choose to resize or break the view.
 * @see View#getMaximumSpan
 */
publicfloatgetMaximumSpan(intaxis) {
updateMetrics();
returnsuper.getMaximumSpan(axis);
 }

/**
 * Gives notification that something was inserted into the
 * document in a location that this view is responsible for.
 * This is implemented to simply update the children.
 *
 * @param e the change information from the associated document
 * @param a the current allocation of the view
 * @param f the factory to use to rebuild if the view has children
 * @see View#insertUpdate
 */
publicvoidinsertUpdate(DocumentEvente, Shapea, ViewFactoryf) {
updateChildren(e, a);

Rectanglealloc = ((a != null) && isAllocationValid()) ?
getInsideAllocation(a) : null;
intpos = e.getOffset();
Viewv = getViewAtPosition(pos, alloc);
if (v != null) {
v.insertUpdate(e, alloc, f);
 }
 }

/**
 * Gives notification that something was removed from the
 * document in a location that this view is responsible for.
 * This is implemented to simply update the children.
 *
 * @param e the change information from the associated document
 * @param a the current allocation of the view
 * @param f the factory to use to rebuild if the view has children
 * @see View#removeUpdate
 */
publicvoidremoveUpdate(DocumentEvente, Shapea, ViewFactoryf) {
updateChildren(e, a);

Rectanglealloc = ((a != null) && isAllocationValid()) ?
getInsideAllocation(a) : null;
intpos = e.getOffset();
Viewv = getViewAtPosition(pos, alloc);
if (v != null) {
v.removeUpdate(e, alloc, f);
 }
 }

/**
 * Gives notification from the document that attributes were changed
 * in a location that this view is responsible for.
 *
 * @param e the change information from the associated document
 * @param a the current allocation of the view
 * @param f the factory to use to rebuild if the view has children
 * @see View#changedUpdate
 */
publicvoidchangedUpdate(DocumentEvente, Shapea, ViewFactoryf) {
updateChildren(e, a);
 }

// --- variables -------------------------------------------

FontMetricsmetrics;
SegmentlineBuffer;
booleanwidthChanging;
inttabBase;
floattabSize;
booleanwordWrap;

intsel0;
intsel1;
Colorunselected;
Colorselected;


/**
 * Simple view of a line that wraps if it doesn't
 * fit within the horizontal space allocated.
 * This class tries to be lightweight by carrying little
 * state of its own and sharing the state of the outer class
 * with its siblings.
 */
classWrappedLineextendsView {

WrappedLine(Elementelem) {
super(elem);
lineCount = -1;
 }

/**
 * Determines the preferred span for this view along an
 * axis.
 *
 * @param axis may be either X_AXIS or Y_AXIS
 * @return the span the view would like to be rendered into.
 * Typically the view is told to render into the span
 * that is returned, although there is no guarantee.
 * The parent may choose to resize or break the view.
 * @see View#getPreferredSpan
 */
publicfloatgetPreferredSpan(intaxis) {
switch (axis) {
caseView.X_AXIS:
floatwidth = getWidth();
if (width == Integer.MAX_VALUE) {
// We have been initially set to MAX_VALUE, but we don't
// want this as our preferred.
return100f;
 }
returnwidth;
caseView.Y_AXIS:
if (lineCount < 0 || widthChanging) {
breakLines(getStartOffset());
 }
returnlineCount * metrics.getHeight();
default:
thrownewIllegalArgumentException("Invalid axis: " + axis);
 }
 }

/**
 * Renders using the given rendering surface and area on that
 * surface. The view may need to do layout and create child
 * views to enable itself to render into the given allocation.
 *
 * @param g the rendering surface to use
 * @param a the allocated region to render into
 * @see View#paint
 */
publicvoidpaint(Graphicsg, Shapea) {
Rectanglealloc = (Rectangle) a;
inty = alloc.y + metrics.getAscent();
intx = alloc.x;

JTextComponenthost = (JTextComponent)getContainer();
Highlighterh = host.getHighlighter();
LayeredHighlighterdh = (hinstanceofLayeredHighlighter) ?
 (LayeredHighlighter)h : null;

intstart = getStartOffset();
intend = getEndOffset();
intp0 = start;
int[] lineEnds = getLineEnds();
booleanuseDrawLineFP = drawLineOverridden && ginstanceofGraphics2D;
for (inti = 0; i < lineCount; i++) {
intp1 = (lineEnds == null) ? end :
start + lineEnds[i];
if (dh != null) {
inthOffset = (p1 == end)
 ? (p1 - 1)
 : p1;
dh.paintLayeredHighlights(g, p0, hOffset, a, host, this);
 }
if (useDrawLineFP) {
drawLine(p0, p1, (Graphics2D) g, (float) x, (float) y);
 } else {
drawLine(p0, p1, g, x, y);
 }
p0 = p1;
y += metrics.getHeight();
 }
 }

/**
 * Provides a mapping from the document model coordinate space
 * to the coordinate space of the view mapped to it.
 *
 * @param pos the position to convert
 * @param a the allocated region to render into
 * @return the bounding box of the given position is returned
 * @throws BadLocationException if the given position does not represent a
 * valid location in the associated document
 * @see View#modelToView
 */
publicShapemodelToView(intpos, Shapea, Position.Biasb)
throwsBadLocationException {
Rectanglealloc = a.getBounds();
alloc.height = metrics.getHeight();
alloc.width = 1;

intp0 = getStartOffset();
if (pos < p0 || pos > getEndOffset()) {
thrownewBadLocationException("Position out of range", pos);
 }

inttestP = (b == Position.Bias.Forward) ? pos :
Math.max(p0, pos - 1);
intline = 0;
int[] lineEnds = getLineEnds();
if (lineEnds != null) {
line = findLine(testP - p0);
if (line > 0) {
p0 += lineEnds[line - 1];
 }
alloc.y += alloc.height * line;
 }

if (pos > p0) {
Segmentsegment = SegmentCache.getSharedSegment();
loadText(segment, p0, pos);
floatx = alloc.x;
x += Utilities.getTabbedTextWidth(segment, metrics, x,
WrappedPlainView.this, p0);
SegmentCache.releaseSharedSegment(segment);
returnnewRectangle2D.Float(x, alloc.y, alloc.width, alloc.height);
 }
returnalloc;
 }

/**
 * Provides a mapping from the view coordinate space to the logical
 * coordinate space of the model.
 *
 * @param fx the X coordinate
 * @param fy the Y coordinate
 * @param a the allocated region to render into
 * @return the location within the model that best represents the
 * given point in the view
 * @see View#viewToModel
 */
publicintviewToModel(floatfx, floatfy, Shapea, Position.Bias[] bias) {
// PENDING(prinz) implement bias properly
bias[0] = Position.Bias.Forward;

Rectanglealloc = (Rectangle) a;
intx = (int) fx;
inty = (int) fy;
if (y < alloc.y) {
// above the area covered by this icon, so the position
// is assumed to be the start of the coverage for this view.
returngetStartOffset();
 } elseif (y > alloc.y + alloc.height) {
// below the area covered by this icon, so the position
// is assumed to be the end of the coverage for this view.
returngetEndOffset() - 1;
 } else {
// positioned within the coverage of this view vertically,
// so we figure out which line the point corresponds to.
// if the line is greater than the number of lines contained, then
// simply use the last line as it represents the last possible place
// we can position to.
alloc.height = metrics.getHeight();
intline = (alloc.height > 0 ?
 (y - alloc.y) / alloc.height : lineCount - 1);
if (line >= lineCount) {
returngetEndOffset() - 1;
 } else {
intp0 = getStartOffset();
intp1;
if (lineCount == 1) {
p1 = getEndOffset();
 } else {
int[] lineEnds = getLineEnds();
p1 = p0 + lineEnds[line];
if (line > 0) {
p0 += lineEnds[line - 1];
 }
 }

if (x < alloc.x) {
// point is to the left of the line
returnp0;
 } elseif (x > alloc.x + alloc.width) {
// point is to the right of the line
returnp1 - 1;
 } else {
// Determine the offset into the text
Segmentsegment = SegmentCache.getSharedSegment();
loadText(segment, p0, p1);
intn = Utilities.getTabbedTextOffset(segment, metrics,
 (float)alloc.x, (float)x,
WrappedPlainView.this, p0, false);
SegmentCache.releaseSharedSegment(segment);
returnMath.min(p0 + n, p1 - 1);
 }
 }
 }
 }

publicvoidinsertUpdate(DocumentEvente, Shapea, ViewFactoryf) {
update(e, a);
 }

publicvoidremoveUpdate(DocumentEvente, Shapea, ViewFactoryf) {
update(e, a);
 }

privatevoidupdate(DocumentEventev, Shapea) {
intoldCount = lineCount;
breakLines(ev.getOffset());
if (oldCount != lineCount) {
WrappedPlainView.this.preferenceChanged(this, false, true);
// have to repaint any views after the receiver.
getContainer().repaint();
 } elseif (a != null) {
Componentc = getContainer();
Rectanglealloc = (Rectangle) a;
c.repaint(alloc.x, alloc.y, alloc.width, alloc.height);
 }
 }

/**
 * Returns line cache. If the cache was GC'ed, recreates it.
 * If there's no cache, returns null
 */
finalint[] getLineEnds() {
if (lineCache == null) {
returnnull;
 } else {
int[] lineEnds = lineCache.get();
if (lineEnds == null) {
// Cache was GC'ed, so rebuild it
returnbreakLines(getStartOffset());
 } else {
returnlineEnds;
 }
 }
 }

/**
 * Creates line cache if text breaks into more than one physical line.
 * @param startPos position to start breaking from
 * @return the cache created, ot null if text breaks into one line
 */
finalint[] breakLines(intstartPos) {
int[] lineEnds = (lineCache == null) ? null : lineCache.get();
int[] oldLineEnds = lineEnds;
intstart = getStartOffset();
intlineIndex = 0;
if (lineEnds != null) {
lineIndex = findLine(startPos - start);
if (lineIndex > 0) {
lineIndex--;
 }
 }

intp0 = (lineIndex == 0) ? start : start + lineEnds[lineIndex - 1];
intp1 = getEndOffset();
while (p0 < p1) {
intp = calculateBreakPosition(p0, p1);
p0 = (p == p0) ? ++p : p; // 4410243

if (lineIndex == 0 && p0 >= p1) {
// do not use cache if there's only one line
lineCache = null;
lineEnds = null;
lineIndex = 1;
break;
 } elseif (lineEnds == null || lineIndex >= lineEnds.length) {
// we have 2+ lines, and the cache is not big enough
// we try to estimate total number of lines
doublegrowFactor = ((double)(p1 - start) / (p0 - start));
intnewSize = (int)Math.ceil((lineIndex + 1) * growFactor);
newSize = Math.max(newSize, lineIndex + 2);
int[] tmp = newint[newSize];
if (lineEnds != null) {
System.arraycopy(lineEnds, 0, tmp, 0, lineIndex);
 }
lineEnds = tmp;
 }
lineEnds[lineIndex++] = p0 - start;
 }

lineCount = lineIndex;
if (lineCount > 1) {
// check if the cache is too big
intmaxCapacity = lineCount + lineCount / 3;
if (lineEnds.length > maxCapacity) {
int[] tmp = newint[maxCapacity];
System.arraycopy(lineEnds, 0, tmp, 0, lineCount);
lineEnds = tmp;
 }
 }

if (lineEnds != null && lineEnds != oldLineEnds) {
lineCache = newSoftReference<int[]>(lineEnds);
 }
returnlineEnds;
 }

/**
 * Binary search in the cache for line containing specified offset
 * (which is relative to the beginning of the view). This method
 * assumes that cache exists.
 */
privateintfindLine(intoffset) {
int[] lineEnds = lineCache.get();
if (offset < lineEnds[0]) {
return0;
 } elseif (offset > lineEnds[lineCount - 1]) {
returnlineCount;
 } else {
returnfindLine(lineEnds, offset, 0, lineCount - 1);
 }
 }

privateintfindLine(int[] array, intoffset, intmin, intmax) {
if (max - min <= 1) {
returnmax;
 } else {
intmid = (max + min) / 2;
return (offset < array[mid]) ?
findLine(array, offset, min, mid) :
findLine(array, offset, mid, max);
 }
 }

intlineCount;
SoftReference<int[]> lineCache = null;
 }

privatefinalbooleandrawLineOverridden =
getFPMethodOverridden(getClass(), "drawLine", IIGNN);
privatefinalbooleandrawSelectedTextOverridden =
getFPMethodOverridden(getClass(), "drawSelectedText", GNNII);
privatefinalbooleandrawUnselectedTextOverridden =
getFPMethodOverridden(getClass(), "drawUnselectedText", GNNII);
privatefinalbooleanuseFloatingPointAPI =
drawUnselectedTextOverridden || drawSelectedTextOverridden;
}