Chip 1998 November/Chip_1998-11_cd.bin/tema/Cafe/jfc.bin/WrappedPlainView.java

Text File | 1998-02-26 | 22KB | 602 lines

/*
 * @(#)WrappedPlainView.java    1.9 98/01/29
 *
 * Copyright (c) 1997 Sun Microsystems, Inc. All Rights Reserved.
 *
 * This software is the confidential and proprietary information of Sun
 * Microsystems, Inc. ("Confidential Information").  You shall not
 * disclose such Confidential Information and shall use it only in
 * accordance with the terms of the license agreement you entered into
 * with Sun.
 *
 * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
 * SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
 * PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
 * SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
 * THIS SOFTWARE OR ITS DERIVATIVES.
 *
 */
package com.sun.java.swing.text;

import java.util.Vector;
import java.util.Properties;
import java.awt.*;
import com.sun.java.swing.event.*;

/**
 * View of plain text (text with only one font and color)
 * that does line-wrapping.  This view expects that it's
 * 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 it's 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
 * it's 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
 * @version 1.9 01/29/98
 * @see     View
 */
public class WrappedPlainView extends BoxView implements TabExpander {

    public WrappedPlainView(Element elem) {
    super(elem, Y_AXIS);
    lineBuffer = new Segment();
    layoutWidth = Short.MAX_VALUE;
    }

    /**
     * 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 exanding 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
     * @param p1 the ending document location to use
     * @param g the graphics context
     * @param x the starting X position
     * @param y the starting Y position
     * @see #drawUnselectedText
     * @see #drawSelectedText
     */
    protected void drawLine(int p0, int p1, Graphics g, int x, int y) {
        try {
            p1 = Math.min(getDocument().getLength(), p1);
            if (sel0 == sel1) {
                // no selection
                drawUnselectedText(g, x, y, p0, p1);
            } else if ((p0 >= sel0 && p0 <= sel1) && (p1 >= sel0 && p1 <= sel1)) {
                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);
                    drawUnselectedText(g, x, y, sel1, p1);
                } else {
                    x = drawUnselectedText(g, x, y, p0, sel0);
                    drawSelectedText(g, x, y, sel0, p1);
                }
            } else if (sel1 >= p0 && sel1 <= p1) {
                x = drawSelectedText(g, x, y, p0, sel1);
                drawUnselectedText(g, x, y, sel1, p1);
            } else {
                drawUnselectedText(g, x, y, p0, p1);
            }
        } catch (BadLocationException e) {
            throw new StateInvariantError("Can't render: " + p0 + "," + p1);
        }
    }

    /**
     * Renders the given range in the model as normal unselected
     * text.
     *
     * @param g the graphics context
     * @param x the starting X coordinate
     * @param y the starting Y coordinate
     * @param p0 the beginning position in the model
     * @param p1 the ending position in the model
     * @returns the location of the end of the range
     * @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();
        doc.getText(p0, p1 - p0, lineBuffer);
        return Utilities.drawTabbedText(lineBuffer, x, y, g, this, p0);
    }

    /**
     * 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
     * @param y the starting Y coordinate
     * @param p0 the beginning position in the model
     * @param p1 the ending position in the model
     * @returns 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();
        doc.getText(p0, p1 - p0, lineBuffer);
        return Utilities.drawTabbedText(lineBuffer, x, y, g, this, p0);
    }

    /**
     * Gives access to a buffer that can be used to fetch
     * text from the associated document.
     *
     * @returns the buffer
     */
    protected final Segment getLineBuffer() {
        return lineBuffer;
    }

    /**
     * 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();
    }

    final void updateMetrics() {
    Component host = getContainer();
    Font f = host.getFont();
    metrics = host.getFontMetrics(f);
    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
     * @param tabOffset the position within the text stream
     *   that the tab occurred at.
     * @return the tab stop, measured in points
     */
    public float nextTabStop(float x, int tabOffset) {
        int ntabs = ((int) x) / tabSize;
        return (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 = a.getBounds();
    if (alloc.width != layoutWidth) {
        layoutWidth = alloc.width;
        preferenceChanged(null, true, true);
    }
    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.getSelectedTextColor() : unselected;
    updateMetrics();
    g.setFont(host.getFont());

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

    /**
     * Sets the size of the view.  If the size has changed, layout
     * is redone.  The size is the full size of the view including
     * the inset areas.
     *
     * @param width the width
     * @param height the height
     */
    public void setSize(float width, float height) {
    updateMetrics();
    super.setSize(width, height);
    }

    /**
     * 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 X_AXIS or Y_AXIS
     * @returns  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);
    }

    /**
     * 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;
    int layoutWidth;
    int tabSize;

    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);
        }

        /**
         * 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(int p0, int p1) {
            try {
                Document doc = getDocument();
                doc.getText(p0, p1 - p0, lineBuffer);
            } catch (BadLocationException bl) {
                throw new StateInvariantError("Can't get line text");
            }
        }

        /**
         * Calculate the number of lines that will be rendered
         * by logical line when it is wrapped.
         */
        final int calculateLineCount() {
            int nlines = 0;
            int p1 = getEndOffset();
            for (int p0 = getStartOffset(); p0 < p1; ) {
                nlines += 1;
                loadText(p0, p1);
                int p = p0 + Utilities.getTabbedTextOffset(lineBuffer, metrics,
                                                           0, layoutWidth,
                                                           WrappedPlainView.this, p0);
                p0 = (p == p0) ? p1 : p;
            }
            return nlines;
        }

        /**
         * Determines the preferred span for this view along an
         * axis.
         *
         * @param axis may be either X_AXIS or Y_AXIS
         * @returns  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:
                return layoutWidth;
            case View.Y_AXIS:
                nlines = calculateLineCount();
                int h = nlines * metrics.getHeight();
                return h;
            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 = a.getBounds();
            int y = alloc.y + metrics.getAscent();
            int x = alloc.x;

            int p1 = getEndOffset();
            for (int p0 = getStartOffset(); p0 < p1; ) {
                loadText(p0, p1);
                int p = p0 + Utilities.getTabbedTextOffset(lineBuffer, metrics,
                                                           x, layoutWidth,
                                                           WrappedPlainView.this, p0);
                drawLine(p0, p, g, x, y);

                p0 = (p == p0) ? p1 : p;
                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) throws BadLocationException {
            Rectangle alloc = a.getBounds();
            alloc.height = metrics.getHeight();
            alloc.width = 1;

            int p1 = getEndOffset();
            for (int p0 = getStartOffset(); p0 < p1; ) {
                loadText(p0, p1);
                int p = p0 + Utilities.getTabbedTextOffset(lineBuffer, metrics,
                                                           alloc.x, alloc.x + layoutWidth,
                                                           WrappedPlainView.this, p0);
                if ((pos >= p0) && (pos < p)) {
                    // it's in this line
                    loadText(p0, pos);
                    alloc.x += Utilities.getTabbedTextWidth(lineBuffer, metrics,
                                                            alloc.x,
                                                            WrappedPlainView.this, p0);
                    return alloc;
                }

                p0 = (p == p0) ? p1 : p;
                alloc.y += alloc.height;
            }
            throw new BadLocationException(null, pos);
        }

        /**
         * Provides a mapping from the view coordinate space to the logical
         * coordinate space of the model.
         *
         * @param x the X coordinate
         * @param y 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) {
        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.
        alloc.height = metrics.getHeight();
        int p1 = getEndOffset();
        for (int p0 = getStartOffset(); p0 < p1; ) {
            loadText(p0, p1);
            int p = p0 + Utilities.getTabbedTextOffset(lineBuffer, metrics,
                                   alloc.x, alloc.x + layoutWidth,
                                   WrappedPlainView.this, p0);
            if ((y >= alloc.y) && (y < (alloc.y + alloc.height))) {
            // it's in this line
            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 p;
            } else {
                // Determine the offset into the text
                int n = Utilities.getTabbedTextOffset(lineBuffer, metrics,
                                    alloc.x, x,
                                    WrappedPlainView.this, p0);
                return Math.min(p0 + n, p1 - 1);
            }
            }

            p0 = (p == p0) ? p1 : p;
            alloc.y += alloc.height;
        }
        return getEndOffset() - 1;
        }
    }

        public void insertUpdate(DocumentEvent e, Shape a, ViewFactory f) {
            int nlines = calculateLineCount();
            if (this.nlines != nlines) {
                this.nlines = nlines;
                WrappedPlainView.this.preferenceChanged(this, false, true);
            } else if (a != null) {
                Component c = getContainer();
                Rectangle alloc = a.getBounds();
                c.repaint(alloc.x, alloc.y, alloc.width, alloc.height);
            }
        }

        public void removeUpdate(DocumentEvent e, Shape a, ViewFactory f) {
            int nlines = calculateLineCount();
            if (this.nlines != nlines) {
                this.nlines = nlines;
                WrappedPlainView.this.preferenceChanged(this, false, true);
            } else if (a != null) {
                Component c = getContainer();
                Rectangle alloc = a.getBounds();
                c.repaint(alloc.x, alloc.y, alloc.width, alloc.height);
            }
        }

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

        int nlines;
    }

}