/* * Copyright (c) 1997, 2006, 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. */package javax.swing.text; import java.util.Vector;import java.util.Properties;import java.awt.*;import javax.swing.event.*; /** * Implements View interface for a simple multi-line text view * that has text in one font and color.  The view represents each * child element as a line of text. * * @author  Timothy Prinzing * @see     View */public class PlainView extends View implements TabExpander {     /**     * Constructs a new PlainView wrapped on an element.     *     * @param elem the element     */    public PlainView(Element elem) {        super(elem);    }     /**     * 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 lineIndex the line to draw >= 0     * @param g the <code>Graphics</code> context     * @param x the starting X position >= 0     * @param y the starting Y position >= 0     * @see #drawUnselectedText     * @see #drawSelectedText     */    protected void drawLine(int lineIndex, Graphics g, int x, int y) {        Element line = getElement().getElement(lineIndex);        Element elem;         try {            if (line.isLeaf()) {                drawElement(lineIndex, line, g, x, y);            } else {                // this line contains the composed text.                int count = line.getElementCount();                for(int i = 0; i < count; i++) {                    elem = line.getElement(i);                    x = drawElement(lineIndex, elem, g, x, y);                }            }        } catch (BadLocationException e) {            throw new StateInvariantError("Can't render line: " + lineIndex);        }    }     private int drawElement(int lineIndex, Element elem, Graphics g, int x, int y) throws BadLocationException {        int p0 = elem.getStartOffset();        int p1 = elem.getEndOffset();        p1 = Math.min(getDocument().getLength(), p1);         if (lineIndex == 0) {            x += firstLineOffset;        }        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.  Uses the foreground or disabled color to render the 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 >= 0     * @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 s = SegmentCache.getSharedSegment();        doc.getText(p0, p1 - p0, s);        int ret = Utilities.drawTabbedText(this, s, x, y, g, this, p0);        SegmentCache.releaseSharedSegment(s);        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 >= 0     * @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 s = SegmentCache.getSharedSegment();        doc.getText(p0, p1 - p0, s);        int ret = Utilities.drawTabbedText(this, s, x, y, g, this, p0);        SegmentCache.releaseSharedSegment(s);        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;    }     /**     * Checks to see if the font metrics and longest line     * are up-to-date.     *     * @since 1.4     */    protected void updateMetrics() {        Component host = getContainer();        Font f = host.getFont();        if (font != f) {            // The font changed, we need to recalculate the            // longest line.            calculateLongestLine();            tabSize = getTabSize() * metrics.charWidth('m');        }    }     // ---- View methods ----------------------------------------------------     /**     * Determines the preferred span for this view along an     * axis.     *     * @param axis may be either View.X_AXIS or View.Y_AXIS     * @return   the span the view would like to be rendered into >= 0.     *           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.     * @exception IllegalArgumentException for an invalid axis     */    public float getPreferredSpan(int axis) {        updateMetrics();        switch (axis) {        case View.X_AXIS:            return getLineWidth(longLine);        case View.Y_AXIS:            return getElement().getElementCount() * metrics.getHeight();        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) {        Shape originalA = a;        a = adjustPaintRegion(a);        Rectangle alloc = (Rectangle) a;        tabBase = alloc.x;        JTextComponent host = (JTextComponent) getContainer();        Highlighter h = host.getHighlighter();        g.setFont(host.getFont());        sel0 = host.getSelectionStart();        sel1 = host.getSelectionEnd();        unselected = (host.isEnabled()) ?            host.getForeground() : host.getDisabledTextColor();        Caret c = host.getCaret();        selected = c.isSelectionVisible() && h != null ?                       host.getSelectedTextColor() : unselected;        updateMetrics();         // If the lines are clipped then we don't expend the effort to        // try and paint them.  Since all of the lines are the same height        // with this object, determination of what lines need to be repainted        // is quick.        Rectangle clip = g.getClipBounds();        int fontHeight = metrics.getHeight();        int heightBelow = (alloc.y + alloc.height) - (clip.y + clip.height);        int heightAbove = clip.y - alloc.y;        int linesBelow, linesAbove, linesTotal;         if (fontHeight > 0) {            linesBelow = Math.max(0, heightBelow / fontHeight);            linesAbove = Math.max(0, heightAbove / fontHeight);            linesTotal = alloc.height / fontHeight;            if (alloc.height % fontHeight != 0) {                linesTotal++;            }        } else {            linesBelow = linesAbove = linesTotal = 0;        }         // update the visible lines        Rectangle lineArea = lineToRect(a, linesAbove);        int y = lineArea.y + metrics.getAscent();        int x = lineArea.x;        Element map = getElement();        int lineCount = map.getElementCount();        int endLine = Math.min(lineCount, linesTotal - linesBelow);        lineCount--;        LayeredHighlighter dh = (h instanceof LayeredHighlighter) ?                           (LayeredHighlighter)h : null;        for (int line = linesAbove; line < endLine; line++) {            if (dh != null) {                Element lineElement = map.getElement(line);                if (line == lineCount) {                    dh.paintLayeredHighlights(g, lineElement.getStartOffset(),                                              lineElement.getEndOffset(),                                              originalA, host, this);                }                else {                    dh.paintLayeredHighlights(g, lineElement.getStartOffset(),                                              lineElement.getEndOffset() - 1,                                              originalA, host, this);                }            }            drawLine(line, g, x, y);            y += fontHeight;            if (line == 0) {                // This should never really happen, in so far as if                // firstLineOffset is non 0, there should only be one                // line of text.                x -= firstLineOffset;            }        }    }     /**     * Should return a shape ideal for painting based on the passed in     * Shape <code>a</code>. This is useful if painting in a different     * region. The default implementation returns <code>a</code>.     */    Shape adjustPaintRegion(Shape a) {        return a;    }     /**     * 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 >= 0     * @param a the allocated region to render into     * @return the bounding box of the given position     * @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 {        // line coordinates        Document doc = getDocument();        Element map = getElement();        int lineIndex = map.getElementIndex(pos);        if (lineIndex < 0) {            return lineToRect(a, 0);        }        Rectangle lineArea = lineToRect(a, lineIndex);         // determine span from the start of the line        tabBase = lineArea.x;        Element line = map.getElement(lineIndex);        int p0 = line.getStartOffset();        Segment s = SegmentCache.getSharedSegment();        doc.getText(p0, pos - p0, s);        int xOffs = Utilities.getTabbedTextWidth(s, metrics, tabBase, this,p0);        SegmentCache.releaseSharedSegment(s);         // fill in the results and return        lineArea.x += xOffs;        lineArea.width = 1;        lineArea.height = metrics.getHeight();        return lineArea;    }     /**     * Provides a mapping from the view coordinate space to the logical     * coordinate space of the model.     *     * @param fx the X coordinate >= 0     * @param fy the Y coordinate >= 0     * @param a the allocated region to render into     * @return the location within the model that best represents the     *  given point in the view >= 0     * @see View#viewToModel     */    public int viewToModel(float fx, float fy, Shape a, Position.Bias[] bias) {        // PENDING(prinz) properly calculate bias        bias[0] = Position.Bias.Forward;         Rectangle alloc = a.getBounds();        Document doc = getDocument();        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.            Element map = doc.getDefaultRootElement();            int fontHeight = metrics.getHeight();            int lineIndex = (fontHeight > 0 ?                                Math.abs((y - alloc.y) / fontHeight) :                                map.getElementCount() - 1);            if (lineIndex >= map.getElementCount()) {                return getEndOffset() - 1;            }            Element line = map.getElement(lineIndex);            int dx = 0;            if (lineIndex == 0) {                alloc.x += firstLineOffset;                alloc.width -= firstLineOffset;            }            if (x < alloc.x) {                // point is to the left of the line                return line.getStartOffset();            } else if (x > alloc.x + alloc.width) {                // point is to the right of the line                return line.getEndOffset() - 1;            } else {                // Determine the offset into the text                try {                    int p0 = line.getStartOffset();                    int p1 = line.getEndOffset() - 1;                    Segment s = SegmentCache.getSharedSegment();                    doc.getText(p0, p1 - p0, s);                    tabBase = alloc.x;                    int offs = p0 + Utilities.getTabbedTextOffset(s, metrics,                                                                  tabBase, x, this, p0);                    SegmentCache.releaseSharedSegment(s);                    return offs;                } catch (BadLocationException e) {                    // should not happen                    return -1;                }            }        }    }     /**     * Gives notification that something was inserted into the document     * in a location that this view is responsible for.     *     * @param changes 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 changes, Shape a, ViewFactory f) {        updateDamage(changes, a, f);    }     /**     * Gives notification that something was removed from the document     * in a location that this view is responsible for.     *     * @param changes 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 changes, Shape a, ViewFactory f) {        updateDamage(changes, a, f);    }     /**     * Gives notification from the document that attributes were changed     * in a location that this view is responsible for.     *     * @param changes 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 changes, Shape a, ViewFactory f) {        updateDamage(changes, a, f);    }     /**     * 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) {        super.setSize(width, height);        updateMetrics();    }     // --- 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

Lines 1–500 of 715. Load more