obtained gcc-4.6.4.tar.bz2 from upstream website;upstream

verified gcc-4.6.4.tar.bz2.sig;
imported gcc-4.6.4 source tree from verified upstream tarball.

downloading a git-generated archive based on the 'upstream' tag
should provide you with a source tree that is binary identical
to the one extracted from the above tarball.

if you have obtained the source via the command 'git clone',
however, do note that line-endings of files in your working
directory might differ from line-endings of the respective
files in the upstream repository.

1 files changed, 1112 insertions, 0 deletions

diff --git a/libjava/classpath/javax/swing/text/BoxView.java b/libjava/classpath/javax/swing/text/BoxView.java
new file mode 100644
index 000000000..325364d2b
--- /dev/null
+++ b/libjava/classpath/javax/swing/text/BoxView.java
@@ -0,0 +1,1112 @@
+/* BoxView.java -- An composite view
+   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.Container;
+import java.awt.Graphics;
+import java.awt.Rectangle;
+import java.awt.Shape;
+
+import javax.swing.SizeRequirements;
+import javax.swing.event.DocumentEvent;
+
+/**
+ * An implementation of {@link CompositeView} that arranges its children in
+ * a box along one axis. This is comparable to how the <code>BoxLayout</code>
+ * works, but for <code>View</code> children.
+ *
+ * @author Roman Kennke (roman@kennke.org)
+ */
+public class BoxView
+  extends CompositeView
+{
+
+  /**
+   * The axis along which this <code>BoxView</code> is laid out.
+   */
+  private int myAxis;
+
+  /**
+   * Indicates if the layout is valid along X_AXIS or Y_AXIS.
+   */
+  private boolean[] layoutValid = new boolean[2];
+
+  /**
+   * Indicates if the requirements for an axis are valid.
+   */
+  private boolean[] requirementsValid = new boolean[2];
+
+  /**
+   * The spans along the X_AXIS and Y_AXIS.
+   */
+  private int[][] spans = new int[2][];
+
+  /**
+   * The offsets of the children along the X_AXIS and Y_AXIS.
+   */
+  private int[][] offsets = new int[2][];
+
+  /**
+   * The size requirements along the X_AXIS and Y_AXIS.
+   */
+  private SizeRequirements[] requirements = new SizeRequirements[2];
+
+  /**
+   * The current span along X_AXIS or Y_AXIS.
+   */
+  private int[] span = new int[2];
+
+  /**
+   * Creates a new <code>BoxView</code> for the given
+   * <code>Element</code> and axis. Valid values for the axis are
+   * {@link View#X_AXIS} and {@link View#Y_AXIS}.
+   *
+   * @param element the element that is rendered by this BoxView
+   * @param axis the axis along which the box is laid out
+   */
+  public BoxView(Element element, int axis)
+  {
+    super(element);
+    myAxis = axis;
+    layoutValid[0] = false;
+    layoutValid[1] = false;
+    requirementsValid[X_AXIS] = false;
+    requirementsValid[Y_AXIS] = false;
+    span[0] = 0;
+    span[1] = 0;
+    requirements[0] = new SizeRequirements();
+    requirements[1] = new SizeRequirements();
+
+    // Initialize the cache arrays.
+    spans[0] = new int[0];
+    spans[1] = new int[0];
+    offsets[0] = new int[0];
+    offsets[1] = new int[0];
+  }
+
+  /**
+   * Returns the axis along which this <code>BoxView</code> is laid out.
+   *
+   * @return the axis along which this <code>BoxView</code> is laid out
+   *
+   * @since 1.3
+   */
+  public int getAxis()
+  {
+    return myAxis;
+  }
+
+  /**
+   * Sets the axis along which this <code>BoxView</code> is laid out.
+   *
+   * Valid values for the axis are {@link View#X_AXIS} and
+   * {@link View#Y_AXIS}.
+   *
+   * @param axis the axis along which this <code>BoxView</code> is laid out
+   *
+   * @since 1.3
+   */
+  public void setAxis(int axis)
+  {
+    boolean changed = axis != myAxis;
+    myAxis = axis;
+    if (changed)
+      preferenceChanged(null, true, true);
+  }
+
+  /**
+   * Marks the layout along the specified axis as invalid. This is triggered
+   * automatically when any of the child view changes its preferences
+   * via {@link #preferenceChanged(View, boolean, boolean)}.
+   *
+   * The layout will be updated the next time when
+   * {@link #setSize(float, float)} is called, typically from within the
+   * {@link #paint(Graphics, Shape)} method.
+   *
+   * Valid values for the axis are {@link View#X_AXIS} and
+   * {@link View#Y_AXIS}.
+   *
+   * @param axis an <code>int</code> value
+   *
+   * @since 1.3
+   */
+  public void layoutChanged(int axis)
+  {
+    if (axis != X_AXIS && axis != Y_AXIS)
+      throw new IllegalArgumentException("Invalid axis parameter.");
+    layoutValid[axis] = false;
+  }
+
+  /**
+   * Returns <code>true</code> if the layout along the specified
+   * <code>axis</code> is valid, <code>false</code> otherwise.
+   *
+   * Valid values for the axis are {@link View#X_AXIS} and
+   * {@link View#Y_AXIS}.
+   *
+   * @param axis the axis
+   *
+   * @return <code>true</code> if the layout along the specified
+   *         <code>axis</code> is valid, <code>false</code> otherwise
+   *
+   * @since 1.4
+   */
+  protected boolean isLayoutValid(int axis)
+  {
+    if (axis != X_AXIS && axis != Y_AXIS)
+      throw new IllegalArgumentException("Invalid axis parameter.");
+    return layoutValid[axis];
+  }
+
+  /**
+   * Paints the child <code>View</code> at the specified <code>index</code>.
+   * This method modifies the actual values in <code>alloc</code> so make
+   * sure you have a copy of the original values if you need them.
+   *
+   * @param g the <code>Graphics</code> context to paint to
+   * @param alloc the allocated region for the child to paint into
+   * @param index the index of the child to be painted
+   *
+   * @see #childAllocation(int, Rectangle)
+   */
+  protected void paintChild(Graphics g, Rectangle alloc, int index)
+  {
+    View child = getView(index);
+    child.paint(g, alloc);
+  }
+
+  /**
+   * Replaces child views by some other child views. If there are no views to
+   * remove (<code>length == 0</code>), the result is a simple insert, if
+   * there are no children to add (<code>view == null</code>) the result
+   * is a simple removal.
+   *
+   * In addition this invalidates the layout and resizes the internal cache
+   * for the child allocations. The old children's cached allocations can
+   * still be accessed (although they are not guaranteed to be valid), and
+   * the new children will have an initial offset and span of 0.
+   *
+   * @param offset the start offset from where to remove children
+   * @param length the number of children to remove
+   * @param views the views that replace the removed children
+   */
+  public void replace(int offset, int length, View[] views)
+  {
+    // Actually perform the replace.
+    super.replace(offset, length, views);
+
+    // Resize and copy data for cache arrays.
+    int newItems = views != null ? views.length : 0;
+    int minor = 1 - myAxis;
+    offsets[myAxis] = replaceLayoutArray(offsets[myAxis], offset, newItems);
+    spans[myAxis] = replaceLayoutArray(spans[myAxis], offset, newItems);
+    layoutValid[myAxis] = false;
+    requirementsValid[myAxis] = false;
+    offsets[minor] = replaceLayoutArray(offsets[minor], offset, newItems);
+    spans[minor] = replaceLayoutArray(spans[minor], offset, newItems);
+    layoutValid[minor] = false;
+    requirementsValid[minor] = false;
+  }
+
+  /**
+   * Helper method. This updates the layout cache arrays in response
+   * to a call to {@link #replace(int, int, View[])}.
+   *
+   * @param oldArray the old array
+   *
+   * @return the replaced array
+   */
+  private int[] replaceLayoutArray(int[] oldArray, int offset, int newItems)
+
+  {
+    int num = getViewCount();
+    int[] newArray = new int[num];
+    System.arraycopy(oldArray, 0, newArray, 0, offset);
+    System.arraycopy(oldArray, offset, newArray, offset + newItems,
+                     num - newItems - offset);
+    return newArray;
+  }
+
+  /**
+   * A Rectangle instance to be reused in the paint() method below.
+   */
+  private final Rectangle tmpRect = new Rectangle();
+
+  private Rectangle clipRect = new Rectangle();
+
+  /**
+   * Renders the <code>Element</code> that is associated with this
+   * <code>View</code>.
+   *
+   * @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)
+  {
+    // Try to avoid allocation if possible (almost all cases).
+    Rectangle alloc = a instanceof Rectangle ? (Rectangle) a : a.getBounds();
+
+    // This returns a cached instance.
+    alloc = getInsideAllocation(alloc);
+
+    int count = getViewCount();
+    for (int i = 0; i < count; i++)
+      {
+        View child = getView(i);
+        tmpRect.setBounds(alloc);
+        childAllocation(i, tmpRect);
+        if (g.hitClip(tmpRect.x, tmpRect.y, tmpRect.width, tmpRect.height))
+          paintChild(g, tmpRect, i);
+      }
+  }
+
+  /**
+   * Returns the preferred span of the content managed by this
+   * <code>View</code> along the specified <code>axis</code>.
+   *
+   * @param axis the axis
+   *
+   * @return the preferred span of this <code>View</code>.
+   */
+  public float getPreferredSpan(int axis)
+  {
+    updateRequirements(axis);
+    // Add margin.
+    float margin;
+    if (axis == X_AXIS)
+      margin = getLeftInset() + getRightInset();
+    else
+      margin = getTopInset() + getBottomInset();
+    return requirements[axis].preferred + margin;
+  }
+
+  /**
+   * Returns the maximum span of this view along the specified axis.
+   * This returns <code>Integer.MAX_VALUE</code> for the minor axis
+   * and the preferred span for the major axis.
+   *
+   * @param axis the axis
+   *
+   * @return the maximum span of this view along the specified axis
+   */
+  public float getMaximumSpan(int axis)
+  {
+    updateRequirements(axis);
+    // Add margin.
+    float margin;
+    if (axis == X_AXIS)
+      margin = getLeftInset() + getRightInset();
+    else
+      margin = getTopInset() + getBottomInset();
+    return requirements[axis].maximum + margin;
+  }
+
+  /**
+   * Returns the minimum span of this view along the specified axis.
+   * This calculates the minimum span using
+   * {@link #calculateMajorAxisRequirements} or
+   * {@link #calculateMinorAxisRequirements} (depending on the axis) and
+   * returns the resulting minimum span.
+   *
+   * @param axis the axis
+   *
+   * @return the minimum span of this view along the specified axis
+   */
+  public float getMinimumSpan(int axis)
+  {
+    updateRequirements(axis);
+    // Add margin.
+    float margin;
+    if (axis == X_AXIS)
+      margin = getLeftInset() + getRightInset();
+    else
+      margin = getTopInset() + getBottomInset();
+    return requirements[axis].minimum + margin;
+  }
+
+  /**
+   * Calculates size requirements for a baseline layout. This is not
+   * used by the BoxView itself, but by subclasses that wish to perform
+   * a baseline layout, like the FlowView's rows.
+   *
+   * @param axis the axis that is examined
+   * @param sr the <code>SizeRequirements</code> object to hold the result,
+   *        if <code>null</code>, a new one is created
+   *
+   * @return the size requirements for this <code>BoxView</code> along
+   *         the specified axis
+   */
+  protected SizeRequirements baselineRequirements(int axis,
+                                                  SizeRequirements sr)
+  {
+    // Create new instance if sr == null.
+    if (sr == null)
+      sr = new SizeRequirements();
+    sr.alignment = 0.5F;
+
+    // Calculate overall ascent and descent.
+    int totalAscentMin = 0;
+    int totalAscentPref = 0;
+    int totalAscentMax = 0;
+    int totalDescentMin = 0;
+    int totalDescentPref = 0;
+    int totalDescentMax = 0;
+
+    int count = getViewCount();
+    for (int i = 0; i < count; i++)
+      {
+        View v = getView(i);
+        float align = v.getAlignment(axis);
+        int span = (int) v.getPreferredSpan(axis);
+        int ascent = (int) (align * span);
+        int descent = span - ascent;
+
+        totalAscentPref = Math.max(ascent, totalAscentPref);
+        totalDescentPref = Math.max(descent, totalDescentPref);
+        if (v.getResizeWeight(axis) > 0)
+          {
+            // If the view is resizable, then use the min and max size
+            // of the view.
+            span = (int) v.getMinimumSpan(axis);
+            ascent = (int) (align * span);
+            descent = span - ascent;
+            totalAscentMin = Math.max(ascent, totalAscentMin);
+            totalDescentMin = Math.max(descent, totalDescentMin);
+
+            span = (int) v.getMaximumSpan(axis);
+            ascent = (int) (align * span);
+            descent = span - ascent;
+            totalAscentMax = Math.max(ascent, totalAscentMax);
+            totalDescentMax = Math.max(descent, totalDescentMax);
+          }
+        else
+          {
+            // If the view is not resizable, use the preferred span.
+            totalAscentMin = Math.max(ascent, totalAscentMin);
+            totalDescentMin = Math.max(descent, totalDescentMin);
+            totalAscentMax = Math.max(ascent, totalAscentMax);
+            totalDescentMax = Math.max(descent, totalDescentMax);
+          }
+      }
+
+    // Preferred overall span is the sum of the preferred ascent and descent.
+    // With overflow check.
+    sr.preferred = (int) Math.min((long) totalAscentPref
+                                  + (long) totalDescentPref,
+                                  Integer.MAX_VALUE);
+
+    // Align along the baseline.
+    if (sr.preferred > 0)
+      sr.alignment = (float) totalAscentPref / sr.preferred;
+
+    if (sr.alignment == 0)
+      {
+        // Nothing above the baseline, use the descent.
+        sr.minimum = totalDescentMin;
+        sr.maximum = totalDescentMax;
+      }
+    else if (sr.alignment == 1.0F)
+      {
+        // Nothing below the baseline, use the descent.
+        sr.minimum = totalAscentMin;
+        sr.maximum = totalAscentMax;
+      }
+    else
+      {
+        sr.minimum = Math.max((int) (totalAscentMin / sr.alignment),
+                              (int) (totalDescentMin / (1.0F - sr.alignment)));
+        sr.maximum = Math.min((int) (totalAscentMax / sr.alignment),
+                              (int) (totalDescentMax / (1.0F - sr.alignment)));
+      }
+    return sr;
+  }
+
+  /**
+   * Calculates the baseline layout of the children of this
+   * <code>BoxView</code> along the specified axis.
+   *
+   * This is not used by the BoxView itself, but by subclasses that wish to
+   * perform a baseline layout, like the FlowView's rows.
+   *
+   * @param span the target span
+   * @param axis the axis that is examined
+   * @param offsets an empty array, filled with the offsets of the children
+   * @param spans an empty array, filled with the spans of the children
+   */
+  protected void baselineLayout(int span, int axis, int[] offsets,
+                                int[] spans)
+  {
+    int totalAscent = (int) (span * getAlignment(axis));
+    int totalDescent = span - totalAscent;
+
+    int count = getViewCount();
+    for (int i = 0; i < count; i++)
+      {
+        View v = getView(i);
+        float align = v.getAlignment(axis);
+        int viewSpan;
+        if (v.getResizeWeight(axis) > 0)
+          {
+            // If possible, then resize for best fit.
+            int min = (int) v.getMinimumSpan(axis);
+            int max = (int) v.getMaximumSpan(axis);
+            if (align == 0.0F)
+              viewSpan = Math.max(Math.min(max, totalDescent), min);
+            else if (align == 1.0F)
+              viewSpan = Math.max(Math.min(max, totalAscent), min);
+            else
+              {
+                int fit = (int) Math.min(totalAscent / align,
+                                         totalDescent / (1.0F - align));
+                viewSpan = Math.max(Math.min(max, fit), min);
+              }
+          }
+        else
+          viewSpan = (int) v.getPreferredSpan(axis);
+        offsets[i] = totalAscent - (int) (viewSpan * align);
+        spans[i] = viewSpan;
+      }
+  }
+
+  /**
+   * Calculates the size requirements of this <code>BoxView</code> along
+   * its major axis, that is the axis specified in the constructor.
+   *
+   * @param axis the axis that is examined
+   * @param sr the <code>SizeRequirements</code> object to hold the result,
+   *        if <code>null</code>, a new one is created
+   *
+   * @return the size requirements for this <code>BoxView</code> along
+   *         the specified axis
+   */
+  protected SizeRequirements calculateMajorAxisRequirements(int axis,
+                                                           SizeRequirements sr)
+  {
+    SizeRequirements res = sr;
+    if (res == null)
+      res = new SizeRequirements();
+
+    float min = 0;
+    float pref = 0;
+    float max = 0;
+
+    int n = getViewCount();
+    for (int i = 0; i < n; i++)
+      {
+        View child = getView(i);
+        min += child.getMinimumSpan(axis);
+        pref += child.getPreferredSpan(axis);
+        max += child.getMaximumSpan(axis);
+      }
+
+    res.minimum = (int) min;
+    res.preferred = (int) pref;
+    res.maximum = (int) max;
+    res.alignment = 0.5F;
+
+    return res;
+  }
+
+  /**
+   * Calculates the size requirements of this <code>BoxView</code> along
+   * its minor axis, that is the axis opposite to the axis specified in the
+   * constructor.
+   *
+   * @param axis the axis that is examined
+   * @param sr the <code>SizeRequirements</code> object to hold the result,
+   *        if <code>null</code>, a new one is created
+   *
+   * @return the size requirements for this <code>BoxView</code> along
+   *         the specified axis
+   */
+  protected SizeRequirements calculateMinorAxisRequirements(int axis,
+                                                            SizeRequirements sr)
+  {
+    SizeRequirements res = sr;
+    if (res == null)
+      res = new SizeRequirements();
+
+    res.minimum = 0;
+    res.preferred = 0;
+    res.maximum = Integer.MAX_VALUE;
+    res.alignment = 0.5F;
+    int n = getViewCount();
+    for (int i = 0; i < n; i++)
+      {
+        View child = getView(i);
+        res.minimum = Math.max((int) child.getMinimumSpan(axis), res.minimum);
+        res.preferred = Math.max((int) child.getPreferredSpan(axis),
+                                 res.preferred);
+        res.maximum = Math.max((int) child.getMaximumSpan(axis), res.maximum);
+      }
+
+    return res;
+  }
+
+
+  /**
+   * Returns <code>true</code> if the specified point lies before the
+   * given <code>Rectangle</code>, <code>false</code> otherwise.
+   *
+   * &quot;Before&quot; is typically defined as being to the left or above.
+   *
+   * @param x the X coordinate of the point
+   * @param y the Y coordinate of the point
+   * @param r the rectangle to test the point against
+   *
+   * @return <code>true</code> if the specified point lies before the
+   *         given <code>Rectangle</code>, <code>false</code> otherwise
+   */
+  protected boolean isBefore(int x, int y, Rectangle r)
+  {
+    boolean result = false;
+
+    if (myAxis == X_AXIS)
+      result = x < r.x;
+    else
+      result = y < r.y;
+
+    return result;
+  }
+
+  /**
+   * Returns <code>true</code> if the specified point lies after the
+   * given <code>Rectangle</code>, <code>false</code> otherwise.
+   *
+   * &quot;After&quot; is typically defined as being to the right or below.
+   *
+   * @param x the X coordinate of the point
+   * @param y the Y coordinate of the point
+   * @param r the rectangle to test the point against
+   *
+   * @return <code>true</code> if the specified point lies after the
+   *         given <code>Rectangle</code>, <code>false</code> otherwise
+   */
+  protected boolean isAfter(int x, int y, Rectangle r)
+  {
+    boolean result = false;
+
+    if (myAxis == X_AXIS)
+      result = x > r.x + r.width;
+    else
+      result = y > r.y + r.height;
+
+    return result;
+  }
+
+  /**
+   * Returns the child <code>View</code> at the specified location.
+   *
+   * @param x the X coordinate
+   * @param y the Y coordinate
+   * @param r the inner allocation of this <code>BoxView</code> on entry,
+   *        the allocation of the found child on exit
+   *
+   * @return the child <code>View</code> at the specified location
+   */
+  protected View getViewAtPoint(int x, int y, Rectangle r)
+  {
+    View result = null;
+    int count = getViewCount();
+    if (myAxis == X_AXIS)
+      {
+        // Border case. Requested point is left from the box.
+        if (x < r.x + offsets[X_AXIS][0])
+          {
+            childAllocation(0, r);
+            result = getView(0);
+          }
+        else
+          {
+            // Search views inside box.
+            for (int i = 0; i < count && result == null; i++)
+              {
+                if (x < r.x + offsets[X_AXIS][i])
+                  {
+                    childAllocation(i - 1, r);
+                    result = getView(i - 1);
+                  }
+              }
+          }
+      }
+    else // Same algorithm for Y_AXIS.
+      {
+        // Border case. Requested point is above the box.
+        if (y < r.y + offsets[Y_AXIS][0])
+          {
+            childAllocation(0, r);
+            result = getView(0);
+          }
+        else
+          {
+            // Search views inside box.
+            for (int i = 0; i < count && result == null; i++)
+              {
+                if (y < r.y + offsets[Y_AXIS][i])
+                  {
+                    childAllocation(i - 1, r);
+                    result = getView(i - 1);
+                  }
+              }
+          }
+      }
+    // Not found, other border case: point is right from or below the box.
+    if (result == null)
+      {
+        childAllocation(count - 1, r);
+        result = getView(count - 1);
+      }
+    return result;
+  }
+
+  /**
+   * Computes the allocation for a child <code>View</code>. The parameter
+   * <code>a</code> stores the allocation of this <code>CompositeView</code>
+   * and is then adjusted to hold the allocation of the child view.
+   *
+   * @param index
+   *          the index of the child <code>View</code>
+   * @param a
+   *          the allocation of this <code>CompositeView</code> before the
+   *          call, the allocation of the child on exit
+   */
+  protected void childAllocation(int index, Rectangle a)
+  {
+    a.x += offsets[X_AXIS][index];
+    a.y += offsets[Y_AXIS][index];
+    a.width = spans[X_AXIS][index];
+    a.height = spans[Y_AXIS][index];
+  }
+
+  /**
+   * Lays out the children of this <code>BoxView</code> with the specified
+   * bounds.
+   *
+   * @param width the width of the allocated region for the children (that
+   *        is the inner allocation of this <code>BoxView</code>
+   * @param height the height of the allocated region for the children (that
+   *        is the inner allocation of this <code>BoxView</code>
+   */
+  protected void layout(int width, int height)
+  {
+    layoutAxis(X_AXIS, width);
+    layoutAxis(Y_AXIS, height);
+  }
+
+  private void layoutAxis(int axis, int s)
+  {
+    if (span[axis] != s)
+      layoutValid[axis] = false;
+    if (! layoutValid[axis])
+      {
+        span[axis] = s;
+        updateRequirements(axis);
+        if (axis == myAxis)
+          layoutMajorAxis(span[axis], axis, offsets[axis], spans[axis]);
+        else
+          layoutMinorAxis(span[axis], axis, offsets[axis], spans[axis]);
+        layoutValid[axis] = true;
+
+        // Push out child layout.
+        int viewCount = getViewCount();
+        for (int i = 0; i < viewCount; i++)
+          {
+            View v = getView(i);
+            v.setSize(spans[X_AXIS][i], spans[Y_AXIS][i]);
+          }
+      }
+  }
+
+  /**
+   * Performs the layout along the major axis of a <code>BoxView</code>.
+   *
+   * @param targetSpan the (inner) span of the <code>BoxView</code> in which
+   *        to layout the children
+   * @param axis the axis along which the layout is performed
+   * @param offsets the array that holds the offsets of the children on exit
+   * @param spans the array that holds the spans of the children on exit
+   */
+  protected void layoutMajorAxis(int targetSpan, int axis, int[] offsets,
+                                 int[] spans)
+  {
+    // Set the spans to the preferred sizes. Determine the space
+    // that we have to adjust the sizes afterwards.
+    long sumPref = 0;
+    int n = getViewCount();
+    for (int i = 0; i < n; i++)
+      {
+        View child = getView(i);
+        spans[i] = (int) child.getPreferredSpan(axis);
+        sumPref += spans[i];
+      }
+
+    // Try to adjust the spans so that we fill the targetSpan.
+    long diff = targetSpan - sumPref;
+    float factor = 0.0F;
+    int[] diffs = null;
+    if (diff != 0)
+      {
+        long total = 0;
+        diffs = new int[n];
+        for (int i = 0; i < n; i++)
+          {
+            View child = getView(i);
+            int span;
+            if (diff < 0)
+              {
+                span = (int) child.getMinimumSpan(axis);
+                diffs[i] = spans[i] - span;
+              }
+            else
+              {
+                span = (int) child.getMaximumSpan(axis);
+                diffs[i] = span - spans[i];
+              }
+            total += span;
+          }
+
+        float maxAdjust = Math.abs(total - sumPref);
+        factor = diff / maxAdjust;
+        factor = Math.min(factor, 1.0F);
+        factor = Math.max(factor, -1.0F);
+      }
+
+    // Actually perform adjustments.
+    int totalOffs = 0;
+    for (int i = 0; i < n; i++)
+      {
+        offsets[i] = totalOffs;
+        if (diff != 0)
+          {
+            float adjust = factor * diffs[i];
+            spans[i] += Math.round(adjust);
+          }
+        // Avoid overflow here.
+        totalOffs = (int) Math.min((long) totalOffs + (long) spans[i],
+                                    Integer.MAX_VALUE);
+      }
+  }
+
+  /**
+   * Performs the layout along the minor axis of a <code>BoxView</code>.
+   *
+   * @param targetSpan the (inner) span of the <code>BoxView</code> in which
+   *        to layout the children
+   * @param axis the axis along which the layout is performed
+   * @param offsets the array that holds the offsets of the children on exit
+   * @param spans the array that holds the spans of the children on exit
+   */
+  protected void layoutMinorAxis(int targetSpan, int axis, int[] offsets,
+                                 int[] spans)
+  {
+    int count = getViewCount();
+    for (int i = 0; i < count; i++)
+      {
+        View child = getView(i);
+        int max = (int) child.getMaximumSpan(axis);
+        if (max < targetSpan)
+          {
+            // Align child when it can't be made as wide as the target span.
+            float align = child.getAlignment(axis);
+            offsets[i] = (int) ((targetSpan - max) * align);
+            spans[i] = max;
+          }
+        else
+          {
+            // Expand child to target width if possible.
+            int min = (int) child.getMinimumSpan(axis);
+            offsets[i] = 0;
+            spans[i] = Math.max(min, targetSpan);
+          }
+      }
+  }
+
+  /**
+   * Returns <code>true</code> if the cached allocations for the children
+   * are still valid, <code>false</code> otherwise.
+   *
+   * @return <code>true</code> if the cached allocations for the children
+   *         are still valid, <code>false</code> otherwise
+   */
+  protected boolean isAllocationValid()
+  {
+    return isLayoutValid(X_AXIS) && isLayoutValid(Y_AXIS);
+  }
+
+  /**
+   * Return the current width of the box. This is the last allocated width.
+   *
+   * @return the current width of the box
+   */
+  public int getWidth()
+  {
+    // The RI returns the following here, however, I'd think that is a bug.
+    // return span[X_AXIS] + getLeftInset() - getRightInset();
+    return span[X_AXIS] + getLeftInset() + getRightInset();
+  }
+
+  /**
+   * Return the current height of the box. This is the last allocated height.
+   *
+   * @return the current height of the box
+   */
+  public int getHeight()
+  {
+    // The RI returns the following here, however, I'd think that is a bug.
+    // return span[Y_AXIS] + getTopInset() - getBottomInset();
+    return span[Y_AXIS] + getTopInset() + getBottomInset();
+  }
+
+  /**
+   * Sets the size of the view. If the actual size has changed, the layout
+   * is updated accordingly.
+   *
+   * @param width the new width
+   * @param height the new height
+   */
+  public void setSize(float width, float height)
+  {
+    layout((int) (width - getLeftInset() - getRightInset()),
+           (int) (height - getTopInset() - getBottomInset()));
+  }
+
+  /**
+   * Returns the span for the child view with the given index for the specified
+   * axis.
+   *
+   * @param axis the axis to examine, either <code>X_AXIS</code> or
+   *        <code>Y_AXIS</code>
+   * @param childIndex the index of the child for for which to return the span
+   *
+   * @return the span for the child view with the given index for the specified
+   *         axis
+   */
+  protected int getSpan(int axis, int childIndex)
+  {
+    if (axis != X_AXIS && axis != Y_AXIS)
+      throw new IllegalArgumentException("Illegal axis argument");
+    return spans[axis][childIndex];
+  }
+
+  /**
+   * Returns the offset for the child view with the given index for the
+   * specified axis.
+   *
+   * @param axis the axis to examine, either <code>X_AXIS</code> or
+   *        <code>Y_AXIS</code>
+   * @param childIndex the index of the child for for which to return the span
+   *
+   * @return the offset for the child view with the given index for the
+   *         specified axis
+   */
+  protected int getOffset(int axis, int childIndex)
+  {
+    if (axis != X_AXIS && axis != Y_AXIS)
+      throw new IllegalArgumentException("Illegal axis argument");
+    return offsets[axis][childIndex];
+  }
+
+  /**
+   * Returns the alignment for this box view for the specified axis. The
+   * axis that is tiled (the major axis) will be requested to be aligned
+   * centered (0.5F). The minor axis alignment depends on the child view's
+   * total alignment.
+   *
+   * @param axis the axis which is examined
+   *
+   * @return the alignment for this box view for the specified axis
+   */
+  public float getAlignment(int axis)
+  {
+     updateRequirements(axis);
+     return requirements[axis].alignment;
+  }
+
+  /**
+   * Called by a child View when its preferred span has changed.
+   *
+   * @param width indicates that the preferred width of the child changed.
+   * @param height indicates that the preferred height of the child changed.
+   * @param child the child View.
+   */
+  public void preferenceChanged(View child, boolean width, boolean height)
+  {
+    if (width)
+      {
+        layoutValid[X_AXIS] = false;
+        requirementsValid[X_AXIS] = false;
+      }
+    if (height)
+      {
+        layoutValid[Y_AXIS] = false;
+        requirementsValid[Y_AXIS] = false;
+      }
+    super.preferenceChanged(child, width, height);
+  }
+
+  /**
+   * Maps the document model position <code>pos</code> to a Shape
+   * in the view coordinate space.  This method overrides CompositeView's
+   * method to make sure the children are allocated properly before
+   * calling the super's behaviour.
+   */
+  public Shape modelToView(int pos, Shape a, Position.Bias bias)
+      throws BadLocationException
+  {
+    // Make sure everything is allocated properly and then call super
+    if (! isAllocationValid())
+      {
+        Rectangle bounds = a.getBounds();
+        setSize(bounds.width, bounds.height);
+      }
+    return super.modelToView(pos, a, bias);
+  }
+
+  /**
+   * Returns the resize weight of this view. A value of <code>0</code> or less
+   * means this view is not resizeable. Positive values make the view
+   * resizeable. This implementation returns <code>0</code> for the major
+   * axis and <code>1</code> for the minor axis of this box view.
+   *
+   * @param axis the axis
+   *
+   * @return the resizability of this view along the specified axis
+   *
+   * @throws IllegalArgumentException if <code>axis</code> is invalid
+   */
+  public int getResizeWeight(int axis)
+  {
+    if (axis != X_AXIS && axis != Y_AXIS)
+      throw new IllegalArgumentException("Illegal axis argument");
+    updateRequirements(axis);
+    int weight = 0;
+    if ((requirements[axis].preferred != requirements[axis].minimum)
+        || (requirements[axis].preferred != requirements[axis].maximum))
+      weight = 1;
+    return weight;
+  }
+
+  /**
+   * Returns the child allocation for the child view with the specified
+   * <code>index</code>. If the layout is invalid, this returns
+   * <code>null</code>.
+   *
+   * @param index the child view index
+   * @param a the allocation to this view
+   *
+   * @return the child allocation for the child view with the specified
+   *         <code>index</code> or <code>null</code> if the layout is invalid
+   *         or <code>a</code> is null
+   */
+  public Shape getChildAllocation(int index, Shape a)
+  {
+    Shape ret = null;
+    if (isAllocationValid() && a != null)
+      ret = super.getChildAllocation(index, a);
+    return ret;
+  }
+
+  protected void forwardUpdate(DocumentEvent.ElementChange ec, DocumentEvent e,
+                               Shape a, ViewFactory vf)
+  {
+    boolean wasValid = isLayoutValid(myAxis);
+    super.forwardUpdate(ec, e, a, vf);
+    // Trigger repaint when one of the children changed the major axis.
+    if (wasValid && ! isLayoutValid(myAxis))
+      {
+        Container c = getContainer();
+        if (a != null && c != null)
+          {
+            int pos = e.getOffset();
+            int index = getViewIndexAtPosition(pos);
+            Rectangle r = getInsideAllocation(a);
+            if (myAxis == X_AXIS)
+              {
+                r.x += offsets[myAxis][index];
+                r.width -= offsets[myAxis][index];
+              }
+            else
+              {
+                r.y += offsets[myAxis][index];
+                r.height -= offsets[myAxis][index];
+              }
+            c.repaint(r.x, r.y, r.width, r.height);
+          }
+      }
+  }
+
+  public int viewToModel(float x, float y, Shape a, Position.Bias[] bias)
+  {
+    if (! isAllocationValid())
+      {
+        Rectangle r = a instanceof Rectangle ? (Rectangle) a : a.getBounds();
+        setSize(r.width, r.height);
+      }
+    return super.viewToModel(x, y, a, bias);
+  }
+
+  protected boolean flipEastAndWestAtEnds(int position, Position.Bias bias)
+  {
+    // FIXME: What to do here?
+    return super.flipEastAndWestAtEnds(position, bias);
+  }
+
+  /**
+   * Updates the view's cached requirements along the specified axis if
+   * necessary. The requirements are only updated if the layout for the
+   * specified axis is marked as invalid.
+   *
+   * @param axis the axis
+   */
+  private void updateRequirements(int axis)
+  {
+    if (axis != Y_AXIS && axis != X_AXIS)
+      throw new IllegalArgumentException("Illegal axis: " + axis);
+    if (! requirementsValid[axis])
+      {
+        if (axis == myAxis)
+          requirements[axis] = calculateMajorAxisRequirements(axis,
+                                                           requirements[axis]);
+        else
+          requirements[axis] = calculateMinorAxisRequirements(axis,
+                                                           requirements[axis]);
+        requirementsValid[axis] = true;
+      }
+  }
+}