Name: jk109818 Date: 04/28/2003


A DESCRIPTION OF THE PROBLEM :
When a paragraph in a JTextPane has a large amount of text the processing needed to layout the entire paragraph increases as the paragraph grows. This error is reported in bug report 4250864. The evaluation and workaround in bug 4250864 stated that an improved FlowStrategy could be installed which uses caching to only layout the part of the paragraph that was modified.

STEPS TO FOLLOW TO REPRODUCE THE PROBLEM :
In a JTextPane type one large paragraph. Use the Windows Task Manager to view the cpu usage.

EXPECTED VERSUS ACTUAL BEHAVIOR :
The cpu usage should not be so directly related to the length of the paragraph.
As the number of "rows" in the paragraph increase the cpu usage steadily increases until the cpu is peaked out.

CUSTOMER SUBMITTED WORKAROUND:
The solution used was to make modifications to javax.swing.text.FlowView. A new class was created called CachedFlowView which uses a CachedFlowStrategy to only layout the last row of the paragraph when the user is typing on the last row. If the user is not typing on the last row then the entire paragraph layout is performed. The think behind this is that most rapid typing is going to be occurring on the last line of the paragraph. If the user is typing on a line other than the last line they are most likely editing the document and don't need the performance. This solution could be improved to perform the layout on all rows below the line the user is editing to improve performance.

With this solution we have found two issues/bugs that may need to be resolved before this would be widely used. One, because the layout is only performed on the last row any editing that would normaly cause the previous line to change no longer occurs (breaking up a long word on the last line that would cause the first part of the word to be placed on the previous line). Two, there appears to be a race condition when there is an extremely long paragraph, the entire paragraph is selected (ctrl+A) and, at the same time, the user types on the last line of the paragraph. The error message is:
     javax.swing.text.StateInvariantError: GlyphView: Stale view: javax.swing.text.BadLocationException: Invalid location

The modifications to FlowView were made by Jason Gilman and Kevin Doyle with thanks to Robert Weikel.

Source code with changes made to FlowView. Changes are marked with "//CHANGE" at the end of the line. Most of the code is directly from FlowView without any changes.

public abstract class CachedFlowView extends BoxView //CHANGE class name
{
    /**
     * Constructs a FlowView for the given element.
     *
     * @param elem the element that this view is responsible for
     * @param axis may be either View.X_AXIS or View.Y_AXIS
     */
    public CachedFlowView(Element elem, int axis)//CHANGE class name

    {
        super(elem, axis);
        layoutSpan = Short.MAX_VALUE;
        strategy = new CachedFlowStrategy(); //CHANGE class name
    }



    /**
     * Fetches the axis along which views should be
     * flowed. By default, this will be the axis
     * orthogonal to the axis along which the flow
     * rows are tiled (the axis of the default flow
     * rows themselves). This is typically used
     * by the <code>FlowStrategy</code>.
     */
    public int getFlowAxis()
    {
        if (getAxis() == Y_AXIS)
        {
            return X_AXIS;
        }
        return Y_AXIS;
    }






    /**
     * Fetch the constraining span to flow against for
     * the given child index. This is called by the
     * FlowStrategy while it is updating the flow.
     * A flow can be shaped by providing different values
     * for the row constraints. By default, the entire
     * span inside of the insets along the flow axis
     * is returned.
     *
     * @param index the index of the row being updated.
     * This should be a value >= 0 and < getViewCount().
     * @see #getFlowStart
     */
    public int getFlowSpan(int index)
    {
        return layoutSpan;
    }

    /**
     * Fetch the location along the flow axis that the
     * flow span will start at. This is called by the
     * FlowStrategy while it is updating the flow.
     * A flow can be shaped by providing different values
     * for the row constraints.

     * @param index the index of the row being updated.
     * This should be a value >= 0 and < getViewCount().
     * @see #getFlowSpan
     */
    public int getFlowStart(int index)
    {
        return 0;
    }

    /**
     * Create a View that should be used to hold a
     * a rows worth of children in a flow. This is
     * called by the FlowStrategy when new children
     * are added or removed (i.e. rows are added or
     * removed) in the process of updating the flow.
     */
    protected abstract View createRow();


    // ---- BoxView methods -------------------------------------

    /**
     * Loads all of the children to initialize the view.
     * This is called by the <code>setParent</code> method.
     * This is reimplemented to not load any children directly
     * (as they are created in the process of formatting).
     * If the layoutPool variable is null, an instance of
     * LogicalView is created to represent the logical view
     * that is used in the process of formatting.
     *
     * @param f the view factory
     */
    protected void loadChildren(ViewFactory f)
    {
        if (layoutPool == null)
        {
            layoutPool = new LogicalView(getElement());
        }
        layoutPool.setParent(this);

        // This synthetic insertUpdate call gives the strategy a chance
        // to initialize.
        strategy.insertUpdate(this, null, null);
    }

    /**
     * Fetches the child view index representing the given position in
     * the model.
     *
     * @param pos the position >= 0
     * @return index of the view representing the given position, or
     * -1 if no view represents that position
     */
    protected int getViewIndexAtPosition(int pos)
    {
        if (pos >= getStartOffset() && (pos < getEndOffset()))
        {
            for (int counter = getViewCount() - 1; counter >= 0; counter--)
            {
                View v = getView(counter);
                if (pos >= v.getStartOffset() && pos < v.getEndOffset())
                {
                    return counter;
                }
            }
        }
        return -1;
    }

    /**
     * Lays out the children. If the span along the flow
     * axis has changed, layout is marked as invalid which
     * which will cause the superclass behavior to recalculate
     * the layout along the box axis. The FlowStrategy.layout
     * method will be called to rebuild the flow rows as
     * appropriate. If the height of this view changes
     * (determined by the perferred size along the box axis),
     * a preferenceChanged is called. Following all of that,
     * the normal box layout of the superclass is performed.
     *
     * @param width the width to lay out against >= 0. This is
     * the width inside of the inset area.
     * @param height the height to lay out against >= 0 This
     * is the height inside of the inset area.
     */
    protected void layout(int width, int height)
    {
        final int faxis = getFlowAxis();
        int newSpan;
        if (faxis == X_AXIS)
        {
            newSpan = (int) width;
        }
        else
        {
            newSpan = (int) height;
        }
        if (layoutSpan != newSpan)
        {
            strategy.allowFullLayout(); //CHANGE need to layout every row
            layoutChanged(faxis);
            layoutChanged(getAxis());
            layoutSpan = newSpan;
        }

        // repair the flow if necessary
        if (! isLayoutValid(faxis))//better for 1.4
            //if( !isAllocationValid() ) //only way possible for 1.3

        {
            final int heightAxis = getAxis();
            int oldFlowHeight =
                    (int)((heightAxis == X_AXIS) ? getWidth() : getHeight());
            strategy.layout(this);
            int newFlowHeight = (int) getPreferredSpan(heightAxis);
            if (oldFlowHeight != newFlowHeight)
            {

                View p = getParent();
                if (p != null)
                {
                    p.preferenceChanged(this, (heightAxis == X_AXIS),
                            (heightAxis == Y_AXIS));
                }
                // PENDING(shannonh)
                // Temporary fix for 4250847
                // Can be removed when TraversalContext is added
                Component host = getContainer();
                if (host != null)
                {
                    //nb idk 12/12/2001 host should not be equal to null. We need to add assertion here
                    host.repaint();
                }
            }
        }

        super.layout(width, height);
    }

    /**
     * Calculate equirements along the minor axis. This
     * is implemented to forward the request to the logical
     * view by calling getMinimumSpan, getPreferredSpan, and
     * getMaximumSpan on it.
     */
    protected SizeRequirements calculateMinorAxisRequirements(int axis,
            SizeRequirements r)
    {
        if (r == null)
        {
            r = new SizeRequirements();
        }
        float pref = layoutPool.getPreferredSpan(axis);
        float min = layoutPool.getMinimumSpan(axis);
        // Don't include insets, Box.getXXXSpan will include them.
        r.minimum = (int) min;
        r.preferred = Math.max(r.minimum, (int) pref);
        r.maximum = Short.MAX_VALUE;
        r.alignment = 0.5f;
        return r;
    }

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

    /**
     * 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)
    {
        layoutPool.insertUpdate(changes, a, f);
        strategy.insertUpdate(this, changes, getInsideAllocation(a));
    }

    /**
     * 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)
    {
        layoutPool.removeUpdate(changes, a, f);
        strategy.removeUpdate(this, changes, getInsideAllocation(a));
    }

    /**
     * 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)
    {
        layoutPool.changedUpdate(changes, a, f);
        strategy.changedUpdate(this, changes, getInsideAllocation(a));
    }

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

    /**
     * Default constraint against which the flow is
     * created against.
     */
    protected int layoutSpan;

    /**
     * These are the views that represent the child elements
     * of the element this view represents (The logical view
     * to translate to a physical view). These are not
     * directly children of this view. These are either
     * placed into the rows directly or used for the purpose
     * of breaking into smaller chunks, to form the physical
     * view.
     */
    protected View layoutPool;

    /**
     * The behavior for keeping the flow updated. By
     * default this is a singleton shared by all instances
     * of FlowView (FlowStrategy is stateless). Subclasses
     * can create an alternative strategy, which might keep
     * state.
     */
    protected CachedFlowStrategy strategy; //CHANGE class name

    /**
     * Strategy for maintaining the physical form
     * of the flow. The default implementation is
     * completely stateless, and recalculates the
     * entire flow if the layout is invalid on the
     * given FlowView. Alternative strategies can
     * be implemented by subclassing, and might
     * perform incrementatal repair to the layout
     * or alternative breaking behavior.
     */
    public static class CachedFlowStrategy //CHANGE class name

    {
        private int rowCount = 0; //CHANGE number of rows in this strategy

        /**
         * Resets numrows and rowstarts to allow full layout of all rows
         * when layout() is called.
         */
        public void allowFullLayout()//CHANGE
        { //CHANGE
            rowCount = 0; //CHANGE
        } //CHANGE

        /**
        * Calls allowFullLayout() if the editing is occuring on any row
        * other than the last row.
        */
        private void checkClearCache(CachedFlowView fv, DocumentEvent e)//CHANGE
        { //CHANGE
            int offset = e.getOffset(); //CHANGE
            int row = fv.getViewIndexAtPosition(offset); //CHANGE
            if (row != rowCount)//CHANGE

            { //CHANGE
                //clear the entire cache and layout everything
                allowFullLayout(); //CHANGE
            } //CHANGE
        } //CHANGE

        /**
         * Gives notification that something was inserted into the document
         * in a location that the given flow view is responsible for. The
         * strategy should update the appropriate changed region (which
         * depends upon the strategy used for repair).
         *
         * @param e the change information from the associated document
         * @param alloc the current allocation of the view inside of the insets.
         * This value will be null if the view has not yet been displayed.
         * @see View#insertUpdate
         */
        public void insertUpdate(CachedFlowView fv, DocumentEvent e,
                Rectangle alloc)
        {
            if (alloc != null)
            {
                //now clear some of the caching
                checkClearCache(fv, e); //CHANGE see if we need to do a full layout

                Component host = fv.getContainer();
                if (host != null)
                {
                    host.repaint(alloc.x, alloc.y, alloc.width, alloc.height);
                }
            }
        }



--> FIX CONTINUED IN WORKAROUND SECTION -->
(Revi
###@###.### 10/11/04 08:51 GMT
ew ID: 184779)
======================================================================