| /* WrappedPlainView.java -- |
| Copyright (C) 2005, 2006 Free Software Foundation, Inc. |
| |
| This file is part of GNU Classpath. |
| |
| GNU Classpath is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 2, or (at your option) |
| any later version. |
| |
| GNU Classpath 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 for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with GNU Classpath; see the file COPYING. If not, write to the |
| Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA |
| 02110-1301 USA. |
| |
| Linking this library statically or dynamically with other modules is |
| making a combined work based on this library. Thus, the terms and |
| conditions of the GNU General Public License cover the whole |
| combination. |
| |
| As a special exception, the copyright holders of this library give you |
| permission to link this library with independent modules to produce an |
| executable, regardless of the license terms of these independent |
| modules, and to copy and distribute the resulting executable under |
| terms of your choice, provided that you also meet, for each linked |
| independent module, the terms and conditions of the license of that |
| module. An independent module is a module which is not derived from |
| or based on this library. If you modify this library, you may extend |
| this exception to your version of the library, but you are not |
| obligated to do so. If you do not wish to do so, delete this |
| exception statement from your version. */ |
| |
| |
| package javax.swing.text; |
| |
| import java.awt.Color; |
| import java.awt.Container; |
| import java.awt.FontMetrics; |
| import java.awt.Graphics; |
| import java.awt.Rectangle; |
| import java.awt.Shape; |
| |
| import javax.swing.event.DocumentEvent; |
| import javax.swing.text.Position.Bias; |
| |
| /** |
| * @author Anthony Balkissoon abalkiss at redhat dot com |
| * |
| */ |
| public class WrappedPlainView extends BoxView implements TabExpander |
| { |
| /** The color for selected text **/ |
| Color selectedColor; |
| |
| /** The color for unselected text **/ |
| Color unselectedColor; |
| |
| /** The color for disabled components **/ |
| Color disabledColor; |
| |
| /** |
| * Stores the font metrics. This is package private to avoid synthetic |
| * accessor method. |
| */ |
| FontMetrics metrics; |
| |
| /** Whether or not to wrap on word boundaries **/ |
| boolean wordWrap; |
| |
| /** A ViewFactory that creates WrappedLines **/ |
| ViewFactory viewFactory = new WrappedLineCreator(); |
| |
| /** The start of the selected text **/ |
| int selectionStart; |
| |
| /** The end of the selected text **/ |
| int selectionEnd; |
| |
| /** The height of the line (used while painting) **/ |
| int lineHeight; |
| |
| /** |
| * The instance returned by {@link #getLineBuffer()}. |
| */ |
| private transient Segment lineBuffer; |
| |
| public WrappedPlainView (Element elem) |
| { |
| this (elem, false); |
| } |
| |
| public WrappedPlainView (Element elem, boolean wordWrap) |
| { |
| super (elem, Y_AXIS); |
| this.wordWrap = wordWrap; |
| } |
| |
| /** |
| * Provides access to the Segment used for retrievals from the Document. |
| * @return the Segment. |
| */ |
| protected final Segment getLineBuffer() |
| { |
| if (lineBuffer == null) |
| lineBuffer = new Segment(); |
| return lineBuffer; |
| } |
| |
| /** |
| * Returns the next tab stop position after a given reference position. |
| * |
| * This implementation ignores the <code>tabStop</code> argument. |
| * |
| * @param x the current x position in pixels |
| * @param tabStop the position within the text stream that the tab occured at |
| */ |
| public float nextTabStop(float x, int tabStop) |
| { |
| JTextComponent host = (JTextComponent)getContainer(); |
| float tabSizePixels = getTabSize() |
| * host.getFontMetrics(host.getFont()).charWidth('m'); |
| return (float) (Math.floor(x / tabSizePixels) + 1) * tabSizePixels; |
| } |
| |
| /** |
| * Returns the tab size for the Document based on |
| * PlainDocument.tabSizeAttribute, defaulting to 8 if this property is |
| * not defined |
| * |
| * @return the tab size. |
| */ |
| protected int getTabSize() |
| { |
| Object tabSize = getDocument().getProperty(PlainDocument.tabSizeAttribute); |
| if (tabSize == null) |
| return 8; |
| return ((Integer)tabSize).intValue(); |
| } |
| |
| /** |
| * Draws a line of text, suppressing white space at the end and expanding |
| * tabs. Calls drawSelectedText and drawUnselectedText. |
| * @param p0 starting document position to use |
| * @param p1 ending document position to use |
| * @param g graphics context |
| * @param x starting x position |
| * @param y starting y position |
| */ |
| protected void drawLine(int p0, int p1, Graphics g, int x, int y) |
| { |
| try |
| { |
| // We have to draw both selected and unselected text. There are |
| // several cases: |
| // - entire range is unselected |
| // - entire range is selected |
| // - start of range is selected, end of range is unselected |
| // - start of range is unselected, end of range is selected |
| // - middle of range is selected, start and end of range is unselected |
| |
| // entire range unselected: |
| if ((selectionStart == selectionEnd) || |
| (p0 > selectionEnd || p1 < selectionStart)) |
| drawUnselectedText(g, x, y, p0, p1); |
| |
| // entire range selected |
| else if (p0 >= selectionStart && p1 <= selectionEnd) |
| drawSelectedText(g, x, y, p0, p1); |
| |
| // start of range selected, end of range unselected |
| else if (p0 >= selectionStart) |
| { |
| x = drawSelectedText(g, x, y, p0, selectionEnd); |
| drawUnselectedText(g, x, y, selectionEnd, p1); |
| } |
| |
| // start of range unselected, end of range selected |
| else if (selectionStart > p0 && selectionEnd > p1) |
| { |
| x = drawUnselectedText(g, x, y, p0, selectionStart); |
| drawSelectedText(g, x, y, selectionStart, p1); |
| } |
| |
| // middle of range selected |
| else if (selectionStart > p0) |
| { |
| x = drawUnselectedText(g, x, y, p0, selectionStart); |
| x = drawSelectedText(g, x, y, selectionStart, selectionEnd); |
| drawUnselectedText(g, x, y, selectionEnd, p1); |
| } |
| } |
| catch (BadLocationException ble) |
| { |
| // shouldn't happen |
| } |
| } |
| |
| /** |
| * Renders the range of text as selected text. Just paints the text |
| * in the color specified by the host component. Assumes the highlighter |
| * will render the selected background. |
| * @param g the graphics context |
| * @param x the starting X coordinate |
| * @param y the starting Y coordinate |
| * @param p0 the starting model location |
| * @param p1 the ending model location |
| * @return the X coordinate of the end of the text |
| * @throws BadLocationException if the given range is invalid |
| */ |
| protected int drawSelectedText(Graphics g, int x, int y, int p0, int p1) |
| throws BadLocationException |
| { |
| g.setColor(selectedColor); |
| Segment segment = getLineBuffer(); |
| getDocument().getText(p0, p1 - p0, segment); |
| return Utilities.drawTabbedText(segment, x, y, g, this, p0); |
| } |
| |
| /** |
| * Renders the range of text as normal unhighlighted text. |
| * @param g the graphics context |
| * @param x the starting X coordinate |
| * @param y the starting Y coordinate |
| * @param p0 the starting model location |
| * @param p1 the end model location |
| * @return the X location of the end off the range |
| * @throws BadLocationException if the range given is invalid |
| */ |
| protected int drawUnselectedText(Graphics g, int x, int y, int p0, int p1) |
| throws BadLocationException |
| { |
| JTextComponent textComponent = (JTextComponent) getContainer(); |
| if (textComponent.isEnabled()) |
| g.setColor(unselectedColor); |
| else |
| g.setColor(disabledColor); |
| |
| Segment segment = getLineBuffer(); |
| getDocument().getText(p0, p1 - p0, segment); |
| return Utilities.drawTabbedText(segment, x, y, g, this, p0); |
| } |
| |
| /** |
| * Loads the children to initiate the view. Called by setParent. |
| * Creates a WrappedLine for each child Element. |
| */ |
| protected void loadChildren (ViewFactory f) |
| { |
| Element root = getElement(); |
| int numChildren = root.getElementCount(); |
| if (numChildren == 0) |
| return; |
| |
| View[] children = new View[numChildren]; |
| for (int i = 0; i < numChildren; i++) |
| children[i] = new WrappedLine(root.getElement(i)); |
| replace(0, 0, children); |
| } |
| |
| /** |
| * Calculates the break position for the text between model positions |
| * p0 and p1. Will break on word boundaries or character boundaries |
| * depending on the break argument given in construction of this |
| * WrappedPlainView. Used by the nested WrappedLine class to determine |
| * when to start the next logical line. |
| * @param p0 the start model position |
| * @param p1 the end model position |
| * @return the model position at which to break the text |
| */ |
| protected int calculateBreakPosition(int p0, int p1) |
| { |
| Container c = getContainer(); |
| |
| int li = getLeftInset(); |
| int ti = getTopInset(); |
| |
| Rectangle alloc = new Rectangle(li, ti, |
| getWidth()-getRightInset()-li, |
| getHeight()-getBottomInset()-ti); |
| |
| // Mimic a behavior observed in the RI. |
| if (alloc.isEmpty()) |
| return 0; |
| |
| updateMetrics(); |
| |
| try |
| { |
| getDocument().getText(p0, p1 - p0, getLineBuffer()); |
| } |
| catch (BadLocationException ble) |
| { |
| // this shouldn't happen |
| throw new InternalError("Invalid offsets p0: " + p0 + " - p1: " + p1); |
| } |
| |
| if (wordWrap) |
| return Utilities.getBreakLocation(lineBuffer, metrics, alloc.x, |
| alloc.x + alloc.width, this, p0); |
| else |
| return p0 + Utilities.getTabbedTextOffset(lineBuffer, metrics, alloc.x, |
| alloc.x + alloc.width, this, 0, |
| true); |
| } |
| |
| void updateMetrics() |
| { |
| Container component = getContainer(); |
| metrics = component.getFontMetrics(component.getFont()); |
| } |
| |
| /** |
| * Determines the preferred span along the given axis. Implemented to |
| * cache the font metrics and then call the super classes method. |
| */ |
| public float getPreferredSpan (int axis) |
| { |
| updateMetrics(); |
| return super.getPreferredSpan(axis); |
| } |
| |
| /** |
| * Determines the minimum span along the given axis. Implemented to |
| * cache the font metrics and then call the super classes method. |
| */ |
| public float getMinimumSpan (int axis) |
| { |
| updateMetrics(); |
| return super.getMinimumSpan(axis); |
| } |
| |
| /** |
| * Determines the maximum span along the given axis. Implemented to |
| * cache the font metrics and then call the super classes method. |
| */ |
| public float getMaximumSpan (int axis) |
| { |
| updateMetrics(); |
| return super.getMaximumSpan(axis); |
| } |
| |
| /** |
| * Called when something was inserted. Overridden so that |
| * the view factory creates WrappedLine views. |
| */ |
| public void insertUpdate (DocumentEvent e, Shape a, ViewFactory f) |
| { |
| super.insertUpdate(e, a, viewFactory); |
| |
| // No repaint needed, as this is done by the WrappedLine instances. |
| } |
| |
| /** |
| * Called when something is removed. Overridden so that |
| * the view factory creates WrappedLine views. |
| */ |
| public void removeUpdate (DocumentEvent e, Shape a, ViewFactory f) |
| { |
| super.removeUpdate(e, a, viewFactory); |
| |
| // No repaint needed, as this is done by the WrappedLine instances. |
| } |
| |
| /** |
| * Called when the portion of the Document that this View is responsible |
| * for changes. Overridden so that the view factory creates |
| * WrappedLine views. |
| */ |
| public void changedUpdate (DocumentEvent e, Shape a, ViewFactory f) |
| { |
| super.changedUpdate(e, a, viewFactory); |
| |
| // No repaint needed, as this is done by the WrappedLine instances. |
| } |
| |
| class WrappedLineCreator implements ViewFactory |
| { |
| // Creates a new WrappedLine |
| public View create(Element elem) |
| { |
| return new WrappedLine(elem); |
| } |
| } |
| |
| /** |
| * Renders the <code>Element</code> that is associated with this |
| * <code>View</code>. Caches the metrics and then calls |
| * super.paint to paint all the child views. |
| * |
| * @param g the <code>Graphics</code> context to render to |
| * @param a the allocated region for the <code>Element</code> |
| */ |
| public void paint(Graphics g, Shape a) |
| { |
| JTextComponent comp = (JTextComponent)getContainer(); |
| // Ensure metrics are up-to-date. |
| updateMetrics(); |
| |
| selectionStart = comp.getSelectionStart(); |
| selectionEnd = comp.getSelectionEnd(); |
| |
| selectedColor = comp.getSelectedTextColor(); |
| unselectedColor = comp.getForeground(); |
| disabledColor = comp.getDisabledTextColor(); |
| selectedColor = comp.getSelectedTextColor(); |
| lineHeight = metrics.getHeight(); |
| g.setFont(comp.getFont()); |
| |
| super.paint(g, a); |
| } |
| |
| /** |
| * Sets the size of the View. Implemented to update the metrics |
| * and then call super method. |
| */ |
| public void setSize (float width, float height) |
| { |
| updateMetrics(); |
| if (width != getWidth()) |
| preferenceChanged(null, true, true); |
| super.setSize(width, height); |
| } |
| |
| class WrappedLine extends View |
| { |
| /** Used to cache the number of lines for this View **/ |
| int numLines = 1; |
| |
| public WrappedLine(Element elem) |
| { |
| super(elem); |
| determineNumLines(); |
| } |
| |
| /** |
| * Renders this (possibly wrapped) line using the given Graphics object |
| * and on the given rendering surface. |
| */ |
| public void paint(Graphics g, Shape s) |
| { |
| Rectangle rect = s.getBounds(); |
| |
| int end = getEndOffset(); |
| int currStart = getStartOffset(); |
| int currEnd; |
| int count = 0; |
| while (currStart < end) |
| { |
| currEnd = calculateBreakPosition(currStart, end); |
| |
| drawLine(currStart, currEnd, g, rect.x, rect.y + metrics.getAscent()); |
| |
| rect.y += lineHeight; |
| if (currEnd == currStart) |
| currStart ++; |
| else |
| currStart = currEnd; |
| |
| count++; |
| |
| } |
| |
| if (count != numLines) |
| { |
| numLines = count; |
| preferenceChanged(this, false, true); |
| } |
| |
| } |
| |
| /** |
| * Calculates the number of logical lines that the Element |
| * needs to be displayed and updates the variable numLines |
| * accordingly. |
| */ |
| void determineNumLines() |
| { |
| numLines = 0; |
| int end = getEndOffset(); |
| if (end == 0) |
| return; |
| |
| int breakPoint; |
| for (int i = getStartOffset(); i < end;) |
| { |
| numLines ++; |
| // careful: check that there's no off-by-one problem here |
| // depending on which position calculateBreakPosition returns |
| breakPoint = calculateBreakPosition(i, end); |
| |
| if (breakPoint == 0) |
| return; |
| |
| // If breakPoint is equal to the current index no further |
| // line is needed and we can end the loop. |
| if (breakPoint == i) |
| break; |
| else |
| i = breakPoint; |
| } |
| } |
| |
| /** |
| * Determines the preferred span for this view along the given axis. |
| * |
| * @param axis the axis (either X_AXIS or Y_AXIS) |
| * |
| * @return the preferred span along the given axis. |
| * @throws IllegalArgumentException if axis is not X_AXIS or Y_AXIS |
| */ |
| public float getPreferredSpan(int axis) |
| { |
| if (axis == X_AXIS) |
| return getWidth(); |
| else if (axis == Y_AXIS) |
| { |
| if (metrics == null) |
| updateMetrics(); |
| return numLines * metrics.getHeight(); |
| } |
| |
| throw new IllegalArgumentException("Invalid axis for getPreferredSpan: " |
| + axis); |
| } |
| |
| /** |
| * Provides a mapping from model space to view space. |
| * |
| * @param pos the position in the model |
| * @param a the region into which the view is rendered |
| * @param b the position bias (forward or backward) |
| * |
| * @return a box in view space that represents the given position |
| * in model space |
| * @throws BadLocationException if the given model position is invalid |
| */ |
| public Shape modelToView(int pos, Shape a, Bias b) |
| throws BadLocationException |
| { |
| Rectangle rect = a.getBounds(); |
| |
| // Throwing a BadLocationException is an observed behavior of the RI. |
| if (rect.isEmpty()) |
| throw new BadLocationException("Unable to calculate view coordinates " |
| + "when allocation area is empty.", 5); |
| |
| Segment s = getLineBuffer(); |
| int lineHeight = metrics.getHeight(); |
| |
| // Return a rectangle with width 1 and height equal to the height |
| // of the text |
| rect.height = lineHeight; |
| rect.width = 1; |
| |
| int currLineStart = getStartOffset(); |
| int end = getEndOffset(); |
| |
| if (pos < currLineStart || pos >= end) |
| throw new BadLocationException("invalid offset", pos); |
| |
| while (true) |
| { |
| int currLineEnd = calculateBreakPosition(currLineStart, end); |
| // If pos is between currLineStart and currLineEnd then just find |
| // the width of the text from currLineStart to pos and add that |
| // to rect.x |
| if (pos >= currLineStart && pos < currLineEnd) |
| { |
| try |
| { |
| getDocument().getText(currLineStart, pos - currLineStart, s); |
| } |
| catch (BadLocationException ble) |
| { |
| // Shouldn't happen |
| } |
| rect.x += Utilities.getTabbedTextWidth(s, metrics, rect.x, |
| WrappedPlainView.this, |
| currLineStart); |
| return rect; |
| } |
| // Increment rect.y so we're checking the next logical line |
| rect.y += lineHeight; |
| |
| // Increment currLineStart to the model position of the start |
| // of the next logical line |
| if (currLineEnd == currLineStart) |
| currLineStart = end; |
| else |
| currLineStart = currLineEnd; |
| } |
| |
| } |
| |
| /** |
| * Provides a mapping from view space to model space. |
| * |
| * @param x the x coordinate in view space |
| * @param y the y coordinate in view space |
| * @param a the region into which the view is rendered |
| * @param b the position bias (forward or backward) |
| * |
| * @return the location in the model that best represents the |
| * given point in view space |
| */ |
| public int viewToModel(float x, float y, Shape a, Bias[] b) |
| { |
| Segment s = getLineBuffer(); |
| Rectangle rect = a.getBounds(); |
| int currLineStart = getStartOffset(); |
| |
| // Although calling modelToView with the last possible offset will |
| // cause a BadLocationException in CompositeView it is allowed |
| // to return that offset in viewToModel. |
| int end = getEndOffset(); |
| |
| int lineHeight = metrics.getHeight(); |
| if (y < rect.y) |
| return currLineStart; |
| |
| if (y > rect.y + rect.height) |
| return end; |
| |
| // Note: rect.x and rect.width do not represent the width of painted |
| // text but the area where text *may* be painted. This means the width |
| // is most of the time identical to the component's width. |
| |
| while (currLineStart != end) |
| { |
| int currLineEnd = calculateBreakPosition(currLineStart, end); |
| |
| // If we're at the right y-position that means we're on the right |
| // logical line and we should look for the character |
| if (y >= rect.y && y < rect.y + lineHeight) |
| { |
| try |
| { |
| getDocument().getText(currLineStart, currLineEnd - currLineStart, s); |
| } |
| catch (BadLocationException ble) |
| { |
| // Shouldn't happen |
| } |
| |
| int offset = Utilities.getTabbedTextOffset(s, metrics, rect.x, |
| (int) x, |
| WrappedPlainView.this, |
| currLineStart); |
| // If the calculated offset is the end of the line (in the |
| // document (= start of the next line) return the preceding |
| // offset instead. This makes sure that clicking right besides |
| // the last character in a line positions the cursor after the |
| // last character and not in the beginning of the next line. |
| return (offset == currLineEnd) ? offset - 1 : offset; |
| } |
| // Increment rect.y so we're checking the next logical line |
| rect.y += lineHeight; |
| |
| // Increment currLineStart to the model position of the start |
| // of the next logical line. |
| currLineStart = currLineEnd; |
| |
| } |
| |
| return end; |
| } |
| |
| /** |
| * <p>This method is called from insertUpdate and removeUpdate.</p> |
| * |
| * <p>If the number of lines in the document has changed, just repaint |
| * the whole thing (note, could improve performance by not repainting |
| * anything above the changes). If the number of lines hasn't changed, |
| * just repaint the given Rectangle.</p> |
| * |
| * <p>Note that the <code>Rectangle</code> argument may be <code>null</code> |
| * when the allocation area is empty.</code> |
| * |
| * @param a the Rectangle to repaint if the number of lines hasn't changed |
| */ |
| void updateDamage (Rectangle a) |
| { |
| // If the allocation area is empty we can't do anything useful. |
| // As determining the number of lines is impossible in that state we |
| // reset it to an invalid value which can then be recalculated at a |
| // later point. |
| if (a == null || a.isEmpty()) |
| { |
| numLines = 1; |
| return; |
| } |
| |
| int oldNumLines = numLines; |
| determineNumLines(); |
| |
| if (numLines != oldNumLines) |
| preferenceChanged(this, false, true); |
| else |
| getContainer().repaint(a.x, a.y, a.width, a.height); |
| } |
| |
| /** |
| * This method is called when something is inserted into the Document |
| * that this View is displaying. |
| * |
| * @param changes the DocumentEvent for the changes. |
| * @param a the allocation of the View |
| * @param f the ViewFactory used to rebuild |
| */ |
| public void insertUpdate (DocumentEvent changes, Shape a, ViewFactory f) |
| { |
| updateDamage((Rectangle)a); |
| } |
| |
| /** |
| * This method is called when something is removed from the Document |
| * that this View is displaying. |
| * |
| * @param changes the DocumentEvent for the changes. |
| * @param a the allocation of the View |
| * @param f the ViewFactory used to rebuild |
| */ |
| public void removeUpdate (DocumentEvent changes, Shape a, ViewFactory f) |
| { |
| // Note: This method is not called when characters from the |
| // end of the document are removed. The reason for this |
| // can be found in the implementation of View.forwardUpdate: |
| // The document event will denote offsets which do not exist |
| // any more, getViewIndex() will therefore return -1 and this |
| // makes View.forwardUpdate() skip this method call. |
| // However this seems to cause no trouble and as it reduces the |
| // number of method calls it can stay this way. |
| |
| updateDamage((Rectangle)a); |
| } |
| } |
| } |
