--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/src/share/classes/javax/swing/text/WrappedPlainView.java Sat Dec 01 00:00:00 2007 +0000
@@ -0,0 +1,877 @@
+/*
+ * Copyright 1998-2006 Sun Microsystems, Inc. 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. Sun designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ */
+package javax.swing.text;
+
+import java.util.Vector;
+import java.util.Properties;
+import java.awt.*;
+import java.lang.ref.SoftReference;
+import javax.swing.event.*;
+
+/**
+ * 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
+ */
+public class WrappedPlainView extends BoxView implements TabExpander {
+
+ /**
+ * Creates a new WrappedPlainView. Lines will be wrapped
+ * on character boundaries.
+ *
+ * @param elem the element underlying the view
+ */
+ public WrappedPlainView(Element elem) {
+ 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?
+ */
+ public WrappedPlainView(Element elem, boolean wordWrap) {
+ super(elem, Y_AXIS);
+ this.wordWrap = wordWrap;
+ }
+
+ /**
+ * Returns the tab size set for the document, defaulting to 8.
+ *
+ * @return the tab size
+ */
+ protected int getTabSize() {
+ Integer i = (Integer) getDocument().getProperty(PlainDocument.tabSizeAttribute);
+ int size = (i != null) ? i.intValue() : 8;
+ return size;
+ }
+
+ /**
+ * 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 >= 0
+ * @param p1 the ending document location to use >= p1
+ * @param g the graphics context
+ * @param x the starting X position >= 0
+ * @param y the starting Y position >= 0
+ * @see #drawUnselectedText
+ * @see #drawSelectedText
+ */
+ protected void drawLine(int p0, int p1, Graphics g, int x, int y) {
+ Element lineMap = getElement();
+ Element line = lineMap.getElement(lineMap.getElementIndex(p0));
+ Element elem;
+
+ try {
+ if (line.isLeaf()) {
+ drawText(line, p0, p1, g, x, y);
+ } else {
+ // this line contains the composed text.
+ int idx = line.getElementIndex(p0);
+ int lastIdx = line.getElementIndex(p1);
+ for(; idx <= lastIdx; idx++) {
+ elem = line.getElement(idx);
+ int start = Math.max(elem.getStartOffset(), p0);
+ int end = Math.min(elem.getEndOffset(), p1);
+ x = drawText(elem, start, end, g, x, y);
+ }
+ }
+ } catch (BadLocationException e) {
+ throw new StateInvariantError("Can't render: " + p0 + "," + p1);
+ }
+ }
+
+ private int drawText(Element elem, int p0, int p1, Graphics g, int x, int y) throws BadLocationException {
+ p1 = Math.min(getDocument().getLength(), p1);
+ AttributeSet attr = 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 = drawUnselectedText(g, x, y, p0, p1);
+ } else if ((p0 >= sel0 && p0 <= sel1) && (p1 >= sel0 && p1 <= sel1)) {
+ x = drawSelectedText(g, x, y, p0, p1);
+ } else if (sel0 >= p0 && sel0 <= p1) {
+ if (sel1 >= p0 && sel1 <= p1) {
+ x = drawUnselectedText(g, x, y, p0, sel0);
+ x = drawSelectedText(g, x, y, sel0, sel1);
+ x = drawUnselectedText(g, x, y, sel1, p1);
+ } else {
+ x = drawUnselectedText(g, x, y, p0, sel0);
+ x = drawSelectedText(g, x, y, sel0, p1);
+ }
+ } else if (sel1 >= p0 && sel1 <= p1) {
+ x = drawSelectedText(g, x, y, p0, sel1);
+ x = drawUnselectedText(g, x, y, sel1, p1);
+ } else {
+ x = drawUnselectedText(g, x, y, p0, p1);
+ }
+ }
+
+ return x;
+ }
+
+ /**
+ * Renders the given range in the model as normal unselected
+ * text.
+ *
+ * @param g the graphics context
+ * @param x the starting X coordinate >= 0
+ * @param y the starting Y coordinate >= 0
+ * @param p0 the beginning position in the model >= 0
+ * @param p1 the ending position in the model >= p0
+ * @return the X location of the end of the range >= 0
+ * @exception BadLocationException if the range is invalid
+ */
+ protected int drawUnselectedText(Graphics g, int x, int y,
+ int p0, int p1) throws BadLocationException {
+ g.setColor(unselected);
+ Document doc = getDocument();
+ Segment segment = SegmentCache.getSharedSegment();
+ doc.getText(p0, p1 - p0, segment);
+ int ret = Utilities.drawTabbedText(this, segment, x, y, g, this, p0);
+ SegmentCache.releaseSharedSegment(segment);
+ return ret;
+ }
+
+ /**
+ * 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 >= 0
+ * @param y the starting Y coordinate >= 0
+ * @param p0 the beginning position in the model >= 0
+ * @param p1 the ending position in the model >= p0
+ * @return the location of the end of the range.
+ * @exception BadLocationException if the range is invalid
+ */
+ protected int drawSelectedText(Graphics g, int x,
+ int y, int p0, int p1) throws BadLocationException {
+ g.setColor(selected);
+ Document doc = getDocument();
+ Segment segment = SegmentCache.getSharedSegment();
+ doc.getText(p0, p1 - p0, segment);
+ int ret = Utilities.drawTabbedText(this, segment, x, y, g, this, p0);
+ SegmentCache.releaseSharedSegment(segment);
+ return ret;
+ }
+
+ /**
+ * Gives access to a buffer that can be used to fetch
+ * text from the associated document.
+ *
+ * @return the buffer
+ */
+ protected final Segment getLineBuffer() {
+ if (lineBuffer == null) {
+ lineBuffer = new Segment();
+ }
+ return lineBuffer;
+ }
+
+ /**
+ * 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.
+ */
+ protected int calculateBreakPosition(int p0, int p1) {
+ int p;
+ Segment segment = SegmentCache.getSharedSegment();
+ loadText(segment, p0, p1);
+ int currentWidth = getWidth();
+ if (currentWidth == Integer.MAX_VALUE) {
+ currentWidth = (int) getDefaultSpan(View.X_AXIS);
+ }
+ if (wordWrap) {
+ p = p0 + Utilities.getBreakLocation(segment, metrics,
+ tabBase, tabBase + currentWidth,
+ this, p0);
+ } else {
+ p = p0 + Utilities.getTabbedTextOffset(segment, metrics,
+ tabBase, tabBase + currentWidth,
+ this, p0, false);
+ }
+ SegmentCache.releaseSharedSegment(segment);
+ return p;
+ }
+
+ /**
+ * 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
+ */
+ protected void loadChildren(ViewFactory f) {
+ Element e = getElement();
+ int n = e.getElementCount();
+ if (n > 0) {
+ View[] added = new View[n];
+ for (int i = 0; i < n; i++) {
+ added[i] = new WrappedLine(e.getElement(i));
+ }
+ replace(0, 0, added);
+ }
+ }
+
+ /**
+ * Update the child views in response to a
+ * document event.
+ */
+ void updateChildren(DocumentEvent e, Shape a) {
+ Element elem = getElement();
+ DocumentEvent.ElementChange ec = e.getChange(elem);
+ if (ec != null) {
+ // the structure of this element changed.
+ Element[] removedElems = ec.getChildrenRemoved();
+ Element[] addedElems = ec.getChildrenAdded();
+ View[] added = new View[addedElems.length];
+ for (int i = 0; i < addedElems.length; i++) {
+ added[i] = new WrappedLine(addedElems[i]);
+ }
+ replace(ec.getIndex(), removedElems.length, added);
+
+ // should damge 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.
+ */
+ final void loadText(Segment segment, int p0, int p1) {
+ try {
+ Document doc = getDocument();
+ doc.getText(p0, p1 - p0, segment);
+ } catch (BadLocationException bl) {
+ throw new StateInvariantError("Can't get line text");
+ }
+ }
+
+ final void updateMetrics() {
+ Component host = getContainer();
+ Font f = host.getFont();
+ metrics = host.getFontMetrics(f);
+ tabSize = getTabSize() * metrics.charWidth('m');
+ }
+
+ /**
+ * Return reasonable default values for the view dimensions. The standard
+ * text terminal size 80x24 is pretty suitable for the wrapped plain view.
+ */
+ private float getDefaultSpan(int axis) {
+ switch (axis) {
+ case View.X_AXIS:
+ return 80 * metrics.getWidths()['M'];
+ case View.Y_AXIS:
+ return 24 * metrics.getHeight();
+ default:
+ throw new IllegalArgumentException("Invalid axis: " + axis);
+ }
+ }
+
+ // --- 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 >= 0
+ * @param tabOffset the position within the text stream
+ * that the tab occurred at >= 0.
+ * @return the tab stop, measured in points >= 0
+ */
+ public float nextTabStop(float x, int tabOffset) {
+ if (tabSize == 0)
+ return x;
+ int ntabs = ((int) x - tabBase) / tabSize;
+ return tabBase + ((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
+ */
+ public void paint(Graphics g, Shape a) {
+ Rectangle alloc = (Rectangle) a;
+ tabBase = alloc.x;
+ JTextComponent host = (JTextComponent) getContainer();
+ sel0 = host.getSelectionStart();
+ sel1 = host.getSelectionEnd();
+ unselected = (host.isEnabled()) ?
+ host.getForeground() : host.getDisabledTextColor();
+ Caret c = 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 >= 0
+ * @param height the height >= 0
+ */
+ public void setSize(float width, float height) {
+ updateMetrics();
+ if ((int) width != getWidth()) {
+ // invalidate the view itself since the childrens
+ // desired widths 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
+ */
+ public float getPreferredSpan(int axis) {
+ updateMetrics();
+ return super.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
+ */
+ public float getMinimumSpan(int axis) {
+ updateMetrics();
+ return super.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
+ */
+ public float getMaximumSpan(int axis) {
+ updateMetrics();
+ return super.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
+ */
+ public void insertUpdate(DocumentEvent e, Shape a, ViewFactory f) {
+ updateChildren(e, a);
+
+ Rectangle alloc = ((a != null) && isAllocationValid()) ?
+ getInsideAllocation(a) : null;
+ int pos = e.getOffset();
+ View v = 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
+ */
+ public void removeUpdate(DocumentEvent e, Shape a, ViewFactory f) {
+ updateChildren(e, a);
+
+ Rectangle alloc = ((a != null) && isAllocationValid()) ?
+ getInsideAllocation(a) : null;
+ int pos = e.getOffset();
+ View v = 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
+ */
+ public void changedUpdate(DocumentEvent e, Shape a, ViewFactory f) {
+ updateChildren(e, a);
+ }
+
+ // --- variables -------------------------------------------
+
+ FontMetrics metrics;
+ Segment lineBuffer;
+ boolean widthChanging;
+ int tabBase;
+ int tabSize;
+ boolean wordWrap;
+
+ int sel0;
+ int sel1;
+ Color unselected;
+ Color selected;
+
+
+ /**
+ * Simple view of a line that wraps if it doesn't
+ * fit withing the horizontal space allocated.
+ * This class tries to be lightweight by carrying little
+ * state of it's own and sharing the state of the outer class
+ * with it's sibblings.
+ */
+ class WrappedLine extends View {
+
+ WrappedLine(Element elem) {
+ 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
+ */
+ public float getPreferredSpan(int axis) {
+ switch (axis) {
+ case View.X_AXIS:
+ float width = getWidth();
+ if (width == Integer.MAX_VALUE) {
+ // We have been initially set to MAX_VALUE, but we don't
+ // want this as our preferred.
+ width = getDefaultSpan(axis);
+ }
+ return width;
+ case View.Y_AXIS:
+ if (getDocument().getLength() > 0) {
+ if ((lineCount < 0) || widthChanging) {
+ breakLines(getStartOffset());
+ }
+ return lineCount * metrics.getHeight();
+ } else {
+ return getDefaultSpan(axis);
+ }
+ default:
+ throw new IllegalArgumentException("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
+ */
+ public void paint(Graphics g, Shape a) {
+ Rectangle alloc = (Rectangle) a;
+ int y = alloc.y + metrics.getAscent();
+ int x = alloc.x;
+
+ JTextComponent host = (JTextComponent)getContainer();
+ Highlighter h = host.getHighlighter();
+ LayeredHighlighter dh = (h instanceof LayeredHighlighter) ?
+ (LayeredHighlighter)h : null;
+
+ int start = getStartOffset();
+ int end = getEndOffset();
+ int p0 = start;
+ int[] lineEnds = getLineEnds();
+ for (int i = 0; i < lineCount; i++) {
+ int p1 = (lineEnds == null) ? end :
+ start + lineEnds[i];
+ if (dh != null) {
+ int hOffset = (p1 == end)
+ ? (p1 - 1)
+ : p1;
+ dh.paintLayeredHighlights(g, p0, hOffset, a, host, this);
+ }
+ 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
+ * @exception BadLocationException if the given position does not represent a
+ * valid location in the associated document
+ * @see View#modelToView
+ */
+ public Shape modelToView(int pos, Shape a, Position.Bias b)
+ throws BadLocationException {
+ Rectangle alloc = a.getBounds();
+ alloc.height = metrics.getHeight();
+ alloc.width = 1;
+
+ int p0 = getStartOffset();
+ if (pos < p0 || pos > getEndOffset()) {
+ throw new BadLocationException("Position out of range", pos);
+ }
+
+ int testP = (b == Position.Bias.Forward) ? pos :
+ Math.max(p0, pos - 1);
+ int line = 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) {
+ Segment segment = SegmentCache.getSharedSegment();
+ loadText(segment, p0, pos);
+ alloc.x += Utilities.getTabbedTextWidth(segment, metrics,
+ alloc.x, WrappedPlainView.this, p0);
+ SegmentCache.releaseSharedSegment(segment);
+ }
+ return alloc;
+ }
+
+ /**
+ * 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
+ */
+ public int viewToModel(float fx, float fy, Shape a, Position.Bias[] bias) {
+ // PENDING(prinz) implement bias properly
+ bias[0] = Position.Bias.Forward;
+
+ Rectangle alloc = (Rectangle) a;
+ int x = (int) fx;
+ int y = (int) fy;
+ if (y < alloc.y) {
+ // above the area covered by this icon, so the the position
+ // is assumed to be the start of the coverage for this view.
+ return getStartOffset();
+ } else if (y > alloc.y + alloc.height) {
+ // below the area covered by this icon, so the the position
+ // is assumed to be the end of the coverage for this view.
+ return getEndOffset() - 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();
+ int line = (alloc.height > 0 ?
+ (y - alloc.y) / alloc.height : lineCount - 1);
+ if (line >= lineCount) {
+ return getEndOffset() - 1;
+ } else {
+ int p0 = getStartOffset();
+ int p1;
+ 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
+ return p0;
+ } else if (x > alloc.x + alloc.width) {
+ // point is to the right of the line
+ return p1 - 1;
+ } else {
+ // Determine the offset into the text
+ Segment segment = SegmentCache.getSharedSegment();
+ loadText(segment, p0, p1);
+ int n = Utilities.getTabbedTextOffset(segment, metrics,
+ alloc.x, x,
+ WrappedPlainView.this, p0);
+ SegmentCache.releaseSharedSegment(segment);
+ return Math.min(p0 + n, p1 - 1);
+ }
+ }
+ }
+ }
+
+ public void insertUpdate(DocumentEvent e, Shape a, ViewFactory f) {
+ update(e, a);
+ }
+
+ public void removeUpdate(DocumentEvent e, Shape a, ViewFactory f) {
+ update(e, a);
+ }
+
+ private void update(DocumentEvent ev, Shape a) {
+ int oldCount = lineCount;
+ breakLines(ev.getOffset());
+ if (oldCount != lineCount) {
+ WrappedPlainView.this.preferenceChanged(this, false, true);
+ // have to repaint any views after the receiver.
+ getContainer().repaint();
+ } else if (a != null) {
+ Component c = getContainer();
+ Rectangle alloc = (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
+ */
+ final int[] getLineEnds() {
+ if (lineCache == null) {
+ return null;
+ } else {
+ int[] lineEnds = lineCache.get();
+ if (lineEnds == null) {
+ // Cache was GC'ed, so rebuild it
+ return breakLines(getStartOffset());
+ } else {
+ return lineEnds;
+ }
+ }
+ }
+
+ /**
+ * 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
+ */
+ final int[] breakLines(int startPos) {
+ int[] lineEnds = (lineCache == null) ? null : lineCache.get();
+ int[] oldLineEnds = lineEnds;
+ int start = getStartOffset();
+ int lineIndex = 0;
+ if (lineEnds != null) {
+ lineIndex = findLine(startPos - start);
+ if (lineIndex > 0) {
+ lineIndex--;
+ }
+ }
+
+ int p0 = (lineIndex == 0) ? start : start + lineEnds[lineIndex - 1];
+ int p1 = getEndOffset();
+ while (p0 < p1) {
+ int p = 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;
+ } else if (lineEnds == null || lineIndex >= lineEnds.length) {
+ // we have 2+ lines, and the cache is not big enough
+ // we try to estimate total number of lines
+ double growFactor = ((double)(p1 - start) / (p0 - start));
+ int newSize = (int)Math.ceil((lineIndex + 1) * growFactor);
+ newSize = Math.max(newSize, lineIndex + 2);
+ int[] tmp = new int[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
+ int maxCapacity = lineCount + lineCount / 3;
+ if (lineEnds.length > maxCapacity) {
+ int[] tmp = new int[maxCapacity];
+ System.arraycopy(lineEnds, 0, tmp, 0, lineCount);
+ lineEnds = tmp;
+ }
+ }
+
+ if (lineEnds != null && lineEnds != oldLineEnds) {
+ lineCache = new SoftReference<int[]>(lineEnds);
+ }
+ return lineEnds;
+ }
+
+ /**
+ * 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.
+ */
+ private int findLine(int offset) {
+ int[] lineEnds = lineCache.get();
+ if (offset < lineEnds[0]) {
+ return 0;
+ } else if (offset > lineEnds[lineCount - 1]) {
+ return lineCount;
+ } else {
+ return findLine(lineEnds, offset, 0, lineCount - 1);
+ }
+ }
+
+ private int findLine(int[] array, int offset, int min, int max) {
+ if (max - min <= 1) {
+ return max;
+ } else {
+ int mid = (max + min) / 2;
+ return (offset < array[mid]) ?
+ findLine(array, offset, min, mid) :
+ findLine(array, offset, mid, max);
+ }
+ }
+
+ int lineCount;
+ SoftReference<int[]> lineCache = null;
+ }
+}