2006-08-05 Roman Kennke <kennke@aicas.com>

	* javax/swing/plaf/basic/BasicTextUI.java
	(damageRange(JTextComponent,int,int)): Call damageRange() with
	correct biases, rather than null.
	(damageRange(JTextComponent,int,int,Bias,Bias)): Rewritten
	to use simpler modelToView() approach without much special
	casing. This seems not worth the effort and actually
	caused problems. Added locking of the document.
	* javax/swing/text/BoxView.java
	(requirementsValid): New field.
	(calculateMajorAxisRequirements): Rewritten without using
	SizeRequirements. The SizeRequirements algorithms are slightly
	different and too inefficient.
	(calculateMinorAxisRequirements): Rewritten without using
	SizeRequirements. The SizeRequirements algorithms are slightly
	different and too inefficient.
	(getAlignment): Simply return the alignment of the cached
	requirements.
	(getMaximumSpan): Add insets.
	(getMinimumSpan): Add insets.
	(getPreferredSpan): Add insets.
	(layoutMajorAxis): Rewritten without using
	SizeRequirements. The SizeRequirements algorithms are slightly
	different and too inefficient.
	(layoutMinorAxis): Rewritten without using
	SizeRequirements. The SizeRequirements algorithms are slightly
	different and too inefficient.
	(modelToView): Call setSize() rather than layout().
	(paint): Check clip for more efficient painting.
	(preferenceChanged): Invalidate requirements here.
	(replace): Invalidate requirements here.
	(updateRequirements): Update requirements only when requirements
	are marked invalid.
	* javax/swing/text/CompositeView.java
	(modelToView): Added some more checks and handling of corner cases.
	* javax/swing/text/FlowView.java
	(calculateMinorAxisRequirements): Set aligment to 0.5 and maximum
	span to Integer.MAX_VALUE. Limit preferredSize to minimumSize.
	* javax/swing/text/IconView.java
	(getAlignment): Implemented to return 1.0 for vertical alignment.
	* javax/swing/text/ParagraphView.java
	(Row.getMaximumSpan): Implemented to let Rows span the whole
	ParagraphView.
	(getAlignment): Fixed horizontal alignment and vertical alignment
	for empty paragraphs to be 0.5.

7 files changed, 308 insertions, 221 deletions

diff --git a/ChangeLog b/ChangeLog
index 01bad9a13..8d62f2e86 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,50 @@
+2006-08-05  Roman Kennke  <kennke@aicas.com>
+
+	* javax/swing/plaf/basic/BasicTextUI.java
+	(damageRange(JTextComponent,int,int)): Call damageRange() with
+	correct biases, rather than null.
+	(damageRange(JTextComponent,int,int,Bias,Bias)): Rewritten
+	to use simpler modelToView() approach without much special
+	casing. This seems not worth the effort and actually
+	caused problems. Added locking of the document.
+	* javax/swing/text/BoxView.java
+	(requirementsValid): New field.
+	(calculateMajorAxisRequirements): Rewritten without using
+	SizeRequirements. The SizeRequirements algorithms are slightly
+	different and too inefficient.
+	(calculateMinorAxisRequirements): Rewritten without using
+	SizeRequirements. The SizeRequirements algorithms are slightly
+	different and too inefficient.
+	(getAlignment): Simply return the alignment of the cached
+	requirements.
+	(getMaximumSpan): Add insets.
+	(getMinimumSpan): Add insets.
+	(getPreferredSpan): Add insets.
+	(layoutMajorAxis): Rewritten without using
+	SizeRequirements. The SizeRequirements algorithms are slightly
+	different and too inefficient.
+	(layoutMinorAxis): Rewritten without using
+	SizeRequirements. The SizeRequirements algorithms are slightly
+	different and too inefficient.
+	(modelToView): Call setSize() rather than layout().
+	(paint): Check clip for more efficient painting.
+	(preferenceChanged): Invalidate requirements here.
+	(replace): Invalidate requirements here.
+	(updateRequirements): Update requirements only when requirements
+	are marked invalid.
+	* javax/swing/text/CompositeView.java
+	(modelToView): Added some more checks and handling of corner cases.
+	* javax/swing/text/FlowView.java
+	(calculateMinorAxisRequirements): Set aligment to 0.5 and maximum
+	span to Integer.MAX_VALUE. Limit preferredSize to minimumSize.
+	* javax/swing/text/IconView.java
+	(getAlignment): Implemented to return 1.0 for vertical alignment.
+	* javax/swing/text/ParagraphView.java
+	(Row.getMaximumSpan): Implemented to let Rows span the whole
+	ParagraphView.
+	(getAlignment): Fixed horizontal alignment and vertical alignment
+	for empty paragraphs to be 0.5.
+
 2006-08-05  Jeroen Frijters  <jeroen@frijters.net>
 
 	* java/awt/Component.java (setDropTarget): Commented out GTK specific
diff --git a/javax/swing/plaf/basic/BasicTextUI.java b/javax/swing/plaf/basic/BasicTextUI.java
index 5febe141d..20480e9d8 100644
--- a/javax/swing/plaf/basic/BasicTextUI.java
+++ b/javax/swing/plaf/basic/BasicTextUI.java
@@ -83,7 +83,6 @@ import javax.swing.text.Highlighter;
 import javax.swing.text.JTextComponent;
 import javax.swing.text.Keymap;
 import javax.swing.text.Position;
-import javax.swing.text.Utilities;
 import javax.swing.text.View;
 import javax.swing.text.ViewFactory;
 
@@ -1042,7 +1041,7 @@ public abstract class BasicTextUI extends TextUI
    */
   public void damageRange(JTextComponent t, int p0, int p1)
   {
-    damageRange(t, p0, p1, null, null);
+    damageRange(t, p0, p1, Position.Bias.Forward, Position.Bias.Backward);
   }
 
   /**
@@ -1062,106 +1061,36 @@ public abstract class BasicTextUI extends TextUI
   public void damageRange(JTextComponent t, int p0, int p1,
                           Position.Bias firstBias, Position.Bias secondBias)
   {
-    // Do nothing if the component cannot be properly displayed.
-    if (t.getWidth() == 0 || t.getHeight() == 0)
-      return;
-    
-    try
+    Rectangle alloc = getVisibleEditorRect();
+    if (alloc != null)
       {
-        // Limit p0 and p1 to sane values to prevent unfriendly
-        // BadLocationExceptions. This makes it possible for the highlighter
-        // to send us illegal values which can happen when a large number
-        // of selected characters are removed (eg. by pressing delete
-        // or backspace).
-        // The reference implementation does not throw an exception, too.
-        p0 = Math.min(p0, t.getDocument().getLength());
-        p1 = Math.min(p1, t.getDocument().getLength());
-
-        Rectangle l1 = modelToView(t, p0, firstBias);
-        Rectangle l2 = modelToView(t, p1, secondBias);
-        if (l1 == null || l2 == null)
+        Document doc = t.getDocument();
+
+        // Acquire lock here to avoid structural changes in between.
+        if (doc instanceof AbstractDocument)
+          ((AbstractDocument) doc).readLock();
+        try
           {
-            // Unable to determine the start or end of the selection.
-            t.repaint();
+            rootView.setSize(alloc.width, alloc.height);
+            Shape damage = rootView.modelToView(p0, firstBias, p1, secondBias,
+                                                alloc);
+            Rectangle r = damage instanceof Rectangle ? (Rectangle) damage
+                                                      : damage.getBounds();
+            textComponent.repaint(r.x, r.y, r.width, r.height);
           }
-        else if (l1.y == l2.y)
+        catch (BadLocationException ex)
           {
-            SwingUtilities.computeUnion(l2.x, l2.y, l2.width, l2.height, l1);
-            t.repaint(l1);
+            // Lets ignore this as it causes no serious problems.
+            // For debugging, comment this out.
+            // ex.printStackTrace();
           }
-        else
+        finally
           {
-            // The two rectangles lie on different lines and we need a
-            // different algorithm to calculate the damaged area:
-            // 1. The line of p0 is damaged from the position of p0
-            // to the right border.
-            // 2. All lines between the ones where p0 and p1 lie on
-            // are completely damaged. Use the allocation area to find
-            // out the bounds.
-            // 3. The final line is damaged from the left bound to the
-            // position of p1.
-            Insets insets = t.getInsets();
-
-            // Damage first line until the end.
-            l1.width = insets.right + t.getWidth() - l1.x;
-            t.repaint(l1);
-            
-            // Note: Utilities.getPositionBelow() may return the offset
-            // that was put in. In that case there is no next line and
-            // we should stop searching for one.
-            
-            int posBelow = Utilities.getPositionBelow(t, p0, l1.x);
-            int p1RowStart = Utilities.getRowStart(t, p1);
-            
-            if (posBelow != -1
-                && posBelow != p0
-                && Utilities.getRowStart(t, posBelow) != p1RowStart)
-              {
-                // Take the rectangle of the offset we just found and grow it
-                // to the maximum width. Retain y because this is our start
-                // height.
-                Rectangle grow = modelToView(t, posBelow);
-                grow.x = insets.left;
-                grow.width = t.getWidth() + insets.right;
-                
-                // Find further lines which have to be damaged completely.
-                int nextPosBelow = posBelow;
-                while (nextPosBelow != -1
-                       && posBelow != nextPosBelow
-                       && Utilities.getRowStart(t, nextPosBelow) != p1RowStart)
-                  {
-                    posBelow = nextPosBelow;
-                    nextPosBelow = Utilities.getPositionBelow(t, posBelow, 
-                                                              l1.x);
-                    
-                    if (posBelow == nextPosBelow)
-                      break;
-                  }
-                // Now posBelow is an offset on the last line which has to be 
-                // damaged completely. (newPosBelow is on the same line as p1)
-                 
-                // Retrieve the rectangle of posBelow and use its y and height
-                // value to calculate the final height of the multiple line
-                // spanning rectangle.
-                Rectangle end = modelToView(t, posBelow);
-                grow.height = end.y + end.height - grow.y;
-                
-                // Mark that area as damage.
-                t.repaint(grow);
-              }
-            
-            // Damage last line from its beginning to the position of p1.
-            l2.width += l2.x;
-            l2.x = insets.left;
-            t.repaint(l2);
+            // Release lock.
+            if (doc instanceof AbstractDocument)
+              ((AbstractDocument) doc).readUnlock();
           }
       }
-    catch (BadLocationException ex)
-      {
-        AssertionError err = new AssertionError("Unexpected bad location");
-        err.initCause(ex);
-        throw err;
-      }
   }
 
   /**
diff --git a/javax/swing/text/BoxView.java b/javax/swing/text/BoxView.java
index a184a8131..27e3c0f9a 100644
--- a/javax/swing/text/BoxView.java
+++ b/javax/swing/text/BoxView.java
@@ -67,6 +67,11 @@ public class BoxView
   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][];
@@ -265,8 +270,10 @@ public class BoxView
     super.replace(offset, length, views);
 
     // Invalidate layout information.
-    layoutChanged(X_AXIS);
-    layoutChanged(Y_AXIS);
+    layoutValid[X_AXIS] = false;
+    requirementsValid[X_AXIS] = false;
+    layoutValid[Y_AXIS] = false;
+    requirementsValid[Y_AXIS] = false;
   }
 
   /**
@@ -278,19 +285,26 @@ public class BoxView
    */
   public void paint(Graphics g, Shape a)
   {
-    Rectangle inside = getInsideAllocation(a);
-    // TODO: Used for debugging.
-    //g.drawRect(inside.x, inside.y, inside.width, inside.height);
+    Rectangle alloc;
+    if (a instanceof Rectangle)
+      alloc = (Rectangle) a;
+    else
+      alloc = a.getBounds();
+
+    int x = alloc.x + getLeftInset();
+    int y = alloc.y + getTopInset();
 
-    Rectangle copy = new Rectangle(inside);
+    Rectangle clip = g.getClipBounds();
+    Rectangle tmp = new Rectangle();
     int count = getViewCount();
     for (int i = 0; i < count; ++i)
       {
-        copy.setBounds(inside);
-        childAllocation(i, copy);
-        if (!copy.isEmpty()
-            && g.hitClip(copy.x, copy.y, copy.width, copy.height))
-          paintChild(g, copy, i);
+        tmp.x = x + getOffset(X_AXIS, i);
+        tmp.y = y + getOffset(Y_AXIS, i);
+        tmp.width = getSpan(X_AXIS, i);
+        tmp.height = getSpan(Y_AXIS, i);
+        if (tmp.intersects(clip))
+          paintChild(g, tmp, i);
       }
   }
 
@@ -305,7 +319,13 @@ public class BoxView
   public float getPreferredSpan(int axis)
   {
     updateRequirements(axis);
-    return requirements[axis].preferred;
+    // Add margin.
+    float margin;
+    if (axis == X_AXIS)
+      margin = getLeftInset() + getRightInset();
+    else
+      margin = getTopInset() + getBottomInset();
+    return requirements[axis].preferred + margin;
   }
 
   /**
@@ -319,12 +339,14 @@ public class BoxView
    */
   public float getMaximumSpan(int axis)
   {
-    float max;
-    if (axis == myAxis)
-      max = getPreferredSpan(axis);
+    updateRequirements(axis);
+    // Add margin.
+    float margin;
+    if (axis == X_AXIS)
+      margin = getLeftInset() + getRightInset();
     else
-      max = Integer.MAX_VALUE;
-    return max;
+      margin = getTopInset() + getBottomInset();
+    return requirements[axis].maximum + margin;
   }
 
   /**
@@ -341,7 +363,13 @@ public class BoxView
   public float getMinimumSpan(int axis)
   {
     updateRequirements(axis);
-    return requirements[axis].minimum;
+    // Add margin.
+    float margin;
+    if (axis == X_AXIS)
+      margin = getLeftInset() + getRightInset();
+    else
+      margin = getTopInset() + getBottomInset();
+    return requirements[axis].minimum + margin;
   }
 
   /**
@@ -435,34 +463,29 @@ public class BoxView
   protected SizeRequirements calculateMajorAxisRequirements(int axis,
                                                            SizeRequirements sr)
   {
-    updateChildRequirements(axis);
+    SizeRequirements res = sr;
+    if (res == null)
+      res = new SizeRequirements();
 
-    SizeRequirements result = sr;
-    if (result == null)
-      result = new SizeRequirements();
+    float min = 0;
+    float pref = 0;
+    float max = 0;
 
-    long minimum = 0;
-    long preferred = 0;
-    long maximum = 0;
-    for (int i = 0; i < children.length; i++)
+    int n = getViewCount();
+    for (int i = 0; i < n; i++)
       {
-        minimum += childReqs[axis][i].minimum;
-        preferred += childReqs[axis][i].preferred;
-        maximum += childReqs[axis][i].maximum;
+        View child = getView(i);
+        min += child.getMinimumSpan(axis);
+        pref = child.getPreferredSpan(axis);
+        max = child.getMaximumSpan(axis);
       }
-    // Overflow check.
-    if (minimum > Integer.MAX_VALUE)
-      minimum = Integer.MAX_VALUE;
-    if (preferred > Integer.MAX_VALUE)
-      preferred = Integer.MAX_VALUE;
-    if (maximum > Integer.MAX_VALUE)
-      maximum = Integer.MAX_VALUE;
-
-    result.minimum = (int) minimum;
-    result.preferred = (int) preferred;
-    result.maximum = (int) maximum;
-    result.alignment = 0.5F;
-    return result;
+
+    res.minimum = (int) min;
+    res.preferred = (int) pref;
+    res.maximum = (int) max;
+    res.alignment = 0.5F;
+
+    return res;
   }
 
   /**
@@ -480,44 +503,24 @@ public class BoxView
   protected SizeRequirements calculateMinorAxisRequirements(int axis,
                                                             SizeRequirements sr)
   {
-    updateChildRequirements(axis);
-
     SizeRequirements res = sr;
     if (res == null)
       res = new SizeRequirements();
 
-    float minLeft = 0;
-    float minRight = 0;
-    float prefLeft = 0;
-    float prefRight = 0;
-    float maxLeft = 0;
-    float maxRight = 0;
-    for (int i = 0; i < childReqs[axis].length; i++)
+    res.minimum = 0;
+    res.preferred = 0;
+    res.maximum = 0;
+    res.alignment = 0.5F;
+    int n = getViewCount();
+    for (int i = 0; i < n; i++)
       {
-        float myMinLeft = childReqs[axis][i].minimum * childReqs[axis][i].alignment;
-        float myMinRight = childReqs[axis][i].minimum - myMinLeft;
-        minLeft = Math.max(myMinLeft, minLeft);
-        minRight = Math.max(myMinRight, minRight);
-        float myPrefLeft = childReqs[axis][i].preferred * childReqs[axis][i].alignment;
-        float myPrefRight = childReqs[axis][i].preferred - myPrefLeft;
-        prefLeft = Math.max(myPrefLeft, prefLeft);
-        prefRight = Math.max(myPrefRight, prefRight);
-        float myMaxLeft = childReqs[axis][i].maximum * childReqs[axis][i].alignment;
-        float myMaxRight = childReqs[axis][i].maximum - myMaxLeft;
-        maxLeft = Math.max(myMaxLeft, maxLeft);
-        maxRight = Math.max(myMaxRight, maxRight);
+        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);
       }
-    int minSize = (int) (minLeft + minRight);
-    int prefSize = (int) (prefLeft + prefRight);
-    int maxSize = (int) (maxLeft + maxRight);
-    float align = prefLeft / (prefRight + prefLeft);
-    if (Float.isNaN(align))
-      align = 0;
 
-    res.alignment = align;
-    res.maximum = maxSize;
-    res.preferred = prefSize;
-    res.minimum = minSize;
     return res;
   }
   
@@ -697,15 +700,62 @@ public class BoxView
   protected void layoutMajorAxis(int targetSpan, int axis, int[] offsets,
                                  int[] spans)
   {
-    updateChildRequirements(axis);
-    updateRequirements(axis);
+    // 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];
+      }
 
-    // Calculate the spans and offsets using the SizeRequirements uility
-    // methods.
-    SizeRequirements.calculateTiledPositions(targetSpan, requirements[axis],
-                                             childReqs[axis],
-                                             offsets, spans);
+    // 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);
+      }
   }
 
   /**
@@ -720,14 +770,26 @@ public class BoxView
   protected void layoutMinorAxis(int targetSpan, int axis, int[] offsets,
                                  int[] spans)
   {
-    updateChildRequirements(axis);
-    updateRequirements(axis);
-
-    // Calculate the spans and offsets using the SizeRequirements uility
-    // methods.
-    SizeRequirements.calculateAlignedPositions(targetSpan, requirements[axis],
-                                               childReqs[axis], offsets,
-                                               spans);
+    int count = getViewCount();
+    for (int i = 0; i < count; i++)
+      {
+        View child = getView(i);
+        int max = (int) child.getMaximumSpan(axis);
+        if (max < targetSpan)
+          {System.err.println("align: " + child);
+            // 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);
+          }
+      }
   }
 
   /**
@@ -822,15 +884,8 @@ public class BoxView
    */
   public float getAlignment(int axis)
   {
-    float align;
-    if (axis == myAxis)
-      align = 0.5F;
-    else
-      {
-        updateRequirements(axis);
-        align = requirements[axis].alignment;
-      }
-    return align;
+     updateRequirements(axis);
+     return requirements[axis].alignment;
   }
   
   /**
@@ -843,9 +898,15 @@ public class BoxView
   public void preferenceChanged(View child, boolean width, boolean height)
   {
     if (width)
-      layoutValid[X_AXIS] = false;
+      {
+        layoutValid[X_AXIS] = false;
+        requirementsValid[X_AXIS] = false;
+      }
     if (height)
-      layoutValid[Y_AXIS] = false;
+      {
+        layoutValid[Y_AXIS] = false;
+        requirementsValid[Y_AXIS] = false;
+      }
     super.preferenceChanged(child, width, height);
   }
   
@@ -862,7 +923,7 @@ public class BoxView
     if (! isAllocationValid())
       {
         Rectangle bounds = a.getBounds();
-        layout(bounds.width, bounds.height);
+        setSize(bounds.width, bounds.height);
       }
     return super.modelToView(pos, a, bias);
   }
@@ -963,7 +1024,7 @@ public class BoxView
    */
   private void updateRequirements(int axis)
   {
-    if (! layoutValid[axis])
+    if (! requirementsValid[axis])
       {
         if (axis == myAxis)
           requirements[axis] = calculateMajorAxisRequirements(axis,
@@ -971,6 +1032,7 @@ public class BoxView
         else
           requirements[axis] = calculateMinorAxisRequirements(axis,
                                                            requirements[axis]);
+        requirementsValid[axis] = true;
       }
   }
 }
diff --git a/javax/swing/text/CompositeView.java b/javax/swing/text/CompositeView.java
index 17f13dbed..5a904b1ea 100644
--- a/javax/swing/text/CompositeView.java
+++ b/javax/swing/text/CompositeView.java
@@ -217,25 +217,43 @@ public abstract class CompositeView
   public Shape modelToView(int pos, Shape a, Position.Bias bias)
     throws BadLocationException
   {
-    int childIndex = getViewIndex(pos, bias);
-    if (childIndex == -1)
-      throw new BadLocationException("Position " + pos + " is not represented by view.", pos);
-      
-    Shape ret = null;
-
-    View child = getView(childIndex);
-    Shape childAlloc = getChildAllocation(childIndex, a);
-    
-    if (childAlloc == null)
-      ret = createDefaultLocation(a, bias);
-    
-    Shape result = child.modelToView(pos, childAlloc, bias);
-
-    if (result != null)
-      ret = result;
-    else
-      ret =  createDefaultLocation(a, bias);
+    boolean backward = bias == Position.Bias.Backward;
+    int testpos = backward ? Math.max(0, pos - 1) : pos;
 
+    Shape ret = null;
+    if (!backward || testpos >= getStartOffset())
+      {
+        int childIndex = getViewIndexAtPosition(testpos);
+        if (childIndex != -1 && childIndex < getViewCount())
+          {
+            View child = getView(childIndex);
+            if (child != null && testpos >= child.getStartOffset()
+                && testpos < child.getEndOffset())
+              {
+                Shape childAlloc = getChildAllocation(childIndex, a);
+                if (childAlloc != null)
+                  {
+                    ret = child.modelToView(pos, childAlloc, bias);
+                    // Handle corner case.
+                    if (ret == null && child.getEndOffset() == pos)
+                      {
+                        childIndex++;
+                        if (childIndex < getViewCount())
+                          {
+                            child = getView(childIndex);
+                            childAlloc = getChildAllocation(childIndex, a);
+                            ret = child.modelToView(pos, childAlloc, bias);
+                          }
+                      }
+                  }
+              }
+          }
+        else
+          {
+            throw new BadLocationException("Position " + pos
+                                           + " is not represented by view.", pos);
+          }    
+      }
     return ret;
   }
 
diff --git a/javax/swing/text/FlowView.java b/javax/swing/text/FlowView.java
index 89fcc6fcd..fb2069c01 100644
--- a/javax/swing/text/FlowView.java
+++ b/javax/swing/text/FlowView.java
@@ -597,12 +597,14 @@ public abstract class FlowView extends BoxView
   protected SizeRequirements calculateMinorAxisRequirements(int axis,
                                                             SizeRequirements r)
   {
-    // We need to call super here so that the alignment is properly
-    // calculated.
-    SizeRequirements res = super.calculateMinorAxisRequirements(axis, r);
+    SizeRequirements res = r;
+    if (res == null)
+      res = new SizeRequirements();
     res.minimum = (int) layoutPool.getMinimumSpan(axis);
-    res.preferred = (int) layoutPool.getPreferredSpan(axis);
-    res.maximum = (int) layoutPool.getMaximumSpan(axis);
+    res.preferred = Math.max(res.minimum,
+                             (int) layoutPool.getMinimumSpan(axis));
+    res.maximum = Integer.MAX_VALUE;
+    res.alignment = 0.5F;
     return res;
   }
 }
diff --git a/javax/swing/text/IconView.java b/javax/swing/text/IconView.java
index 699cda90e..7bb7635b4 100644
--- a/javax/swing/text/IconView.java
+++ b/javax/swing/text/IconView.java
@@ -44,7 +44,6 @@ import java.awt.Shape;
 
 import javax.swing.Icon;
 import javax.swing.JTextPane;
-import javax.swing.SwingConstants;
 
 /**
  * A View that can render an icon. This view is created by the
@@ -156,4 +155,21 @@ public class IconView
     return el.getStartOffset();
   }
 
+  /**
+   * Returns the alignment for this view. This will be 1.0 for the Y_AXIS,
+   * and the super behaviour for the X_AXIS.
+   *
+   * @param axis the axis for which to calculate the alignment
+   *
+   * @return the alignment
+   */
+  public float getAlignment(int axis)
+  {
+    float align;
+    if (axis == Y_AXIS)
+      align = 1.0F;
+    else
+      align = super.getAlignment(axis);
+    return align;
+  }
 }
diff --git a/javax/swing/text/ParagraphView.java b/javax/swing/text/ParagraphView.java
index 15bed7818..177ed454b 100644
--- a/javax/swing/text/ParagraphView.java
+++ b/javax/swing/text/ParagraphView.java
@@ -74,6 +74,19 @@ public class ParagraphView extends FlowView implements TabExpander
       return align;
     }
 
+    /**
+     * Allows rows to span the whole parent view.
+     */
+    public float getMaximumSpan(int axis)
+    {
+      float max;
+      if (axis == X_AXIS)
+        max = Float.MAX_VALUE;
+      else
+        max = super.getMaximumSpan(axis);
+      return max;
+    }
+
     protected void loadChildren(ViewFactory vf)
     {
       // Do nothing here. The children are added while layouting.
@@ -140,7 +153,7 @@ public class ParagraphView extends FlowView implements TabExpander
   {
     float align;
     if (axis == X_AXIS)
-      align = super.getAlignment(axis);
+      align = 0.5F;
     else if (getViewCount() > 0)
       {
         float prefHeight = getPreferredSpan(Y_AXIS);
@@ -148,7 +161,7 @@ public class ParagraphView extends FlowView implements TabExpander
         align = (firstRowHeight / 2.F) / prefHeight;
       }
     else
-      align = 0.0F;
+      align = 0.5F;
     return align;
   }