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

	* javax/swing/SwingUtilities.java
	(clipString): New helper method for trimming strings.
	(layoutCompoundLabelImpl): Fixed algorithm to conform
	testsuites. Trim text if it's too long. Avoid creating
	new Rectangles. Optimized for performance.
	(layoutCompoundLabel): Use switch rather then if-else-chain.
	* javax/swing/plaf/basic/BasicButtonUI.java
	(viewR): New field.
	(iconR): New field.
	(textR): New field.
	(paint): Reset and use cached rectangles. Only call paintIcon()
	if icon is not null. Don't call paintButtonPressed() when
	button is selected, only when it is both armed and pressed.
	* javax/swing/plaf/basic/BasicGraphicsUtils.java
	(getPreferredButtonSize): Reused cached rectangles rather
	then creating new ones. Don't create new Rectangle via
	Rectangle.union().
	* javax/swing/plaf/basic/BasicLabelUI.java
	(getPreferredSize): Correctly reset cached rectangles. Especially
	the view rect must have a big size to give it room for layouting.
	Short cut layout when text == null.
	(paint): Correctly reset cached rectangles.
	* javax/swing/plaf/basic/BasicMenuItemUI.java
	(resetRectangles): New helper method.
	(getPreferredMenuItemSize): Correctly reset the cached rectangles.
	(paintMenuItem): Correctly reset the cached rectangles.
	* javax/swing/plaf/basic/BasicRadioButtonUI.java
	(getPreferredSize): Use cached Rectangle objects and initialize
	them correctly.
	(paint): Use cached Rectangle objects and initialize
	them correctly.

6 files changed, 297 insertions, 162 deletions

diff --git a/javax/swing/SwingUtilities.java b/javax/swing/SwingUtilities.java
index ba4c708fb..c6e50fba5 100644
--- a/javax/swing/SwingUtilities.java
+++ b/javax/swing/SwingUtilities.java
@@ -40,7 +40,6 @@ package javax.swing;
 
 import java.applet.Applet;
 import java.awt.Component;
-import java.awt.ComponentOrientation;
 import java.awt.Container;
 import java.awt.FontMetrics;
 import java.awt.Frame;
@@ -721,38 +720,35 @@ public class SwingUtilities
 
     // Fix up the orientation-based horizontal positions.
 
-    if (horizontalTextPosition == LEADING)
-      {
-        if (c.getComponentOrientation() == ComponentOrientation.RIGHT_TO_LEFT)
-          horizontalTextPosition = RIGHT;
-        else
-          horizontalTextPosition = LEFT;
-      }
-    else if (horizontalTextPosition == TRAILING)
+    boolean ltr = true;
+    if (c != null && ! c.getComponentOrientation().isLeftToRight())
+      ltr = false;
+
+    switch (horizontalTextPosition)
       {
-        if (c.getComponentOrientation() == ComponentOrientation.RIGHT_TO_LEFT)
-          horizontalTextPosition = LEFT;
-        else
-          horizontalTextPosition = RIGHT;
+      case LEADING:
+        horizontalTextPosition = ltr ? LEFT : RIGHT;
+        break;
+      case TRAILING:
+        horizontalTextPosition = ltr ? RIGHT : LEFT;
+        break;
+      default:
+        // Nothing to do in the other cases.
       }
 
     // Fix up the orientation-based alignments.
-
-    if (horizontalAlignment == LEADING)
-      {
-        if (c.getComponentOrientation() == ComponentOrientation.RIGHT_TO_LEFT)
-          horizontalAlignment = RIGHT;
-        else
-          horizontalAlignment = LEFT;
-      }
-    else if (horizontalAlignment == TRAILING)
+    switch (horizontalAlignment)
       {
-        if (c.getComponentOrientation() == ComponentOrientation.RIGHT_TO_LEFT)
-          horizontalAlignment = LEFT;
-        else
-          horizontalAlignment = RIGHT;
+        case LEADING:
+          horizontalAlignment = ltr ? LEFT : RIGHT;
+          break;
+        case TRAILING:
+          horizontalAlignment = ltr ? RIGHT : LEFT;
+          break;
+        default:
+          // Nothing to do in the other cases.
       }
-    
+
     return layoutCompoundLabelImpl(c, fm, text, icon,
                                    verticalAlignment,
                                    horizontalAlignment,
@@ -921,104 +917,108 @@ public class SwingUtilities
         iconR.width = icon.getIconWidth();
         iconR.height = icon.getIconHeight();
       }
+
     if (text == null || text.equals(""))
       {
         textIconGap = 0;
 	textR.width = 0;
 	textR.height = 0;
+        text = "";
       }
     else
       {
+        int availableWidth = viewR.width;
+        if (horizontalTextPosition != CENTER)
+          availableWidth -= iconR.width + textIconGap;
         View html = c == null ? null
                            : (View) c.getClientProperty(BasicHTML.propertyKey);
         if (html != null)
           {
             textR.width = (int) html.getPreferredSpan(View.X_AXIS);
+            textR.width = Math.min(availableWidth, textR.width);
             textR.height = (int) html.getPreferredSpan(View.Y_AXIS);
           }
         else
           {
             int fromIndex = 0;
             textR.width = fm.stringWidth(text);
-            textR.height = fm.getHeight(); 
-            while (text.indexOf('\n', fromIndex) != -1)
+            textR.height = fm.getHeight();
+            if (textR.width > availableWidth)
               {
-                textR.height += fm.getHeight();
-                fromIndex = text.indexOf('\n', fromIndex) + 1;
+                text = clipString(c, fm, text, availableWidth);
+                textR.width = fm.stringWidth(text);
               }
           }
       }
 
-    // Work out the position of text and icon, assuming the top-left coord
+    // Work out the position of text, assuming the top-left coord
     // starts at (0,0). We will fix that up momentarily, after these
     // "position" decisions are made and we look at alignment.
 
-    switch (horizontalTextPosition)
+    switch (verticalTextPosition)
       {
-      case LEFT:
-        textR.x = 0;
-        iconR.x = textR.width + textIconGap;
+      case TOP:
+        textR.y = horizontalTextPosition == CENTER ?
+                  - textR.height - textIconGap : 0;
         break;
-      case RIGHT:
-        iconR.x = 0;
-        textR.x = iconR.width + textIconGap;
+      case BOTTOM:
+        textR.y = horizontalTextPosition == CENTER ?
+                  iconR.height + textIconGap : iconR.height - textR.height;
         break;
       case CENTER:
-        int centerLine = Math.max(textR.width, iconR.width) / 2;
-        textR.x = centerLine - textR.width/2;
-        iconR.x = centerLine - iconR.width/2;
+        textR.y = iconR.height / 2 - textR.height / 2;
         break;
       }
 
-    switch (verticalTextPosition)
+    switch (horizontalTextPosition)
       {
-      case TOP:
-        textR.y = 0;
-        iconR.y = (horizontalTextPosition == CENTER 
-                   ? textR.height + textIconGap : 0);
+      case LEFT:
+        textR.x = -(textR.width + textIconGap);
         break;
-      case BOTTOM:
-        iconR.y = 0;
-        textR.y = (horizontalTextPosition == CENTER
-                   ? iconR.height + textIconGap 
-                   : Math.max(iconR.height - textR.height, 0));
+      case RIGHT:
+        textR.x = iconR.width + textIconGap;
         break;
       case CENTER:
-        int centerLine = Math.max(textR.height, iconR.height) / 2;
-        textR.y = centerLine - textR.height/2;
-        iconR.y = centerLine - iconR.height/2;
+        textR.x = iconR.width / 2 - textR.width / 2;
         break;
       }
+
     // The two rectangles are laid out correctly now, but only assuming
     // that their upper left corner is at (0,0). If we have any alignment other
     // than TOP and LEFT, we need to adjust them.
 
-    Rectangle u = textR.union(iconR);
-    int horizontalAdjustment = viewR.x;
-    int verticalAdjustment = viewR.y;
+    // These coordinates specify the rectangle that contains both the
+    // icon and text. Move it so that it fullfills the alignment properties.
+    int lx = Math.min(iconR.x, textR.x);
+    int lw = Math.max(iconR.x + iconR.width, textR.x + textR.width) - lx;
+    int ly = Math.min(iconR.y, textR.y);
+    int lh = Math.max(iconR.y + iconR.height, textR.y + textR.height) - ly;
+    int horizontalAdjustment = 0;
+    int verticalAdjustment = 0;
     switch (verticalAlignment)
       {
       case TOP:
+        verticalAdjustment = viewR.y - ly;
         break;
       case BOTTOM:
-        verticalAdjustment += (viewR.height - u.height);
+        verticalAdjustment = viewR.y + viewR.height - ly - lh;
         break;
       case CENTER:
-        verticalAdjustment += ((viewR.height/2) - (u.height/2));
+        verticalAdjustment = viewR.y + viewR.height / 2 - ly  - lh / 2;
         break;
       }
     switch (horizontalAlignment)
       {
       case LEFT:
+        horizontalAdjustment = viewR.x - lx;
         break;
       case RIGHT:
-        horizontalAdjustment += (viewR.width - u.width);
+        horizontalAdjustment = viewR.x + viewR.width - lx - lw;
         break;
       case CENTER:
-        horizontalAdjustment += ((viewR.width/2) - (u.width/2));
+        horizontalAdjustment = (viewR.x + (viewR.width / 2)) - (lx + (lw / 2));
         break;
       }
-
     iconR.x += horizontalAdjustment;
     iconR.y += verticalAdjustment;
 
@@ -1028,6 +1028,48 @@ public class SwingUtilities
     return text;
   }
 
+  /**
+   * The method clips the specified string so that it fits into the
+   * available width. It is only called when the text really doesn't fit,
+   * so we don't need to check that again.
+   *
+   * @param c the component
+   * @param fm the font metrics
+   * @param text the text
+   * @param availableWidth the available width
+   *
+   * @return the clipped string
+   */
+  private static String clipString(JComponent c, FontMetrics fm, String text,
+                                   int availableWidth)
+  {
+    String dots = "...";
+    int dotsWidth = fm.stringWidth(dots);
+    char[] string = text.toCharArray();
+    int endIndex = string.length;
+    while (fm.charsWidth(string, 0, endIndex) + dotsWidth > availableWidth
+           && endIndex > 0)
+      endIndex--;
+    String clipped;
+    if (string.length >= endIndex + 3)
+      {
+        string[endIndex] = '.';
+        string[endIndex + 1] = '.';
+        string[endIndex + 2] = '.';
+        clipped = new String(string, 0, endIndex + 3);
+      }
+    else
+      {
+        char[] clippedChars = new char[string.length + 3];
+        System.arraycopy(string, 0, clippedChars, 0, string.length);
+        clippedChars[endIndex] = '.';
+        clippedChars[endIndex + 1] = '.';
+        clippedChars[endIndex + 2] = '.';
+        clipped = new String(clippedChars, 0, endIndex + 3);
+      }
+    return clipped;
+  }
+
   /** 
    * Calls {@link java.awt.EventQueue#invokeLater} with the
    * specified {@link Runnable}. 
diff --git a/javax/swing/plaf/basic/BasicButtonUI.java b/javax/swing/plaf/basic/BasicButtonUI.java
index cdaec2543..96b11a00d 100644
--- a/javax/swing/plaf/basic/BasicButtonUI.java
+++ b/javax/swing/plaf/basic/BasicButtonUI.java
@@ -42,6 +42,7 @@ import java.awt.Dimension;
 import java.awt.Font;
 import java.awt.FontMetrics;
 import java.awt.Graphics;
+import java.awt.Insets;
 import java.awt.Rectangle;
 
 import javax.swing.AbstractButton;
@@ -64,6 +65,24 @@ import javax.swing.text.View;
 public class BasicButtonUI extends ButtonUI
 {
   /**
+   * Cached rectangle for layouting the label. Used in paint() and
+   * BasicGraphicsUtils.getPreferredButtonSize().
+   */
+  static Rectangle viewR = new Rectangle();
+
+  /**
+   * Cached rectangle for layouting the label. Used in paint() and
+   * BasicGraphicsUtils.getPreferredButtonSize().
+   */
+  static Rectangle iconR = new Rectangle();
+
+  /**
+   * Cached rectangle for layouting the label. Used in paint() and
+   * BasicGraphicsUtils.getPreferredButtonSize().
+   */
+  static Rectangle textR = new Rectangle();
+
+  /**
    * A constant used to pad out elements in the button's layout and
    * preferred size calculations.
    */
@@ -378,44 +397,50 @@ public class BasicButtonUI extends ButtonUI
   {
     AbstractButton b = (AbstractButton) c;
 
-    Rectangle tr = new Rectangle();
-    Rectangle ir = new Rectangle();
-    Rectangle vr = new Rectangle();
+    Insets i = c.getInsets();
+    viewR.x = i.left;
+    viewR.y = i.top;
+    viewR.width = c.getWidth() - i.left - i.right;
+    viewR.height = c.getHeight() - i.top - i.bottom;
+    textR.x = 0;
+    textR.y = 0;
+    textR.width = 0;
+    textR.height = 0;
+    iconR.x = 0;
+    iconR.y = 0;
+    iconR.width = 0;
+    iconR.height = 0;
 
     Font f = c.getFont();
-
     g.setFont(f);
+    Icon icon = b.getIcon();
+    String text = b.getText();
+    text = SwingUtilities.layoutCompoundLabel(c, g.getFontMetrics(f), 
+                                              text, icon,
+                                              b.getVerticalAlignment(), 
+                                              b.getHorizontalAlignment(),
+                                              b.getVerticalTextPosition(), 
+                                              b.getHorizontalTextPosition(),
+                                              viewR, iconR, textR, 
+                                              text == null ? 0
+                                                         : b.getIconTextGap());
 
-    if (b.isBorderPainted())
-      SwingUtilities.calculateInnerArea(b, vr);
-    else
-      vr = SwingUtilities.getLocalBounds(b);
-    String text = SwingUtilities.layoutCompoundLabel(c, g.getFontMetrics(f), 
-                                                     b.getText(),
-                                                     currentIcon(b),
-                                                     b.getVerticalAlignment(), 
-                                                     b.getHorizontalAlignment(),
-                                                     b.getVerticalTextPosition(), 
-                                                     b.getHorizontalTextPosition(),
-                                                     vr, ir, tr, 
-                                                     b.getIconTextGap() 
-                                                     + defaultTextShiftOffset);
-    
-    if ((b.getModel().isArmed() && b.getModel().isPressed()) 
-        || b.isSelected())
+    ButtonModel model = b.getModel();
+    if (model.isArmed() && model.isPressed())
       paintButtonPressed(g, b);
-	
-    paintIcon(g, c, ir);
+
+    if (icon != null)
+      paintIcon(g, c, iconR);
     if (text != null)
       {
         View html = (View) b.getClientProperty(BasicHTML.propertyKey);
         if (html != null)
-          html.paint(g, tr);
+          html.paint(g, textR);
         else
-          paintText(g, b, tr, text);
+          paintText(g, b, textR, text);
       }
     if (b.isFocusOwner() && b.isFocusPainted())
-      paintFocus(g, b, vr, tr, ir);
+      paintFocus(g, b, viewR, textR, iconR);
   }
 
   /**
diff --git a/javax/swing/plaf/basic/BasicGraphicsUtils.java b/javax/swing/plaf/basic/BasicGraphicsUtils.java
index 1e84be932..4c270682d 100644
--- a/javax/swing/plaf/basic/BasicGraphicsUtils.java
+++ b/javax/swing/plaf/basic/BasicGraphicsUtils.java
@@ -748,7 +748,6 @@ public class BasicGraphicsUtils
     }
   }
 
-
   /**
    * Determines the preferred width and height of an AbstractButton,
    * given the gap between the button’s text and icon.
@@ -769,24 +768,31 @@ public class BasicGraphicsUtils
   public static Dimension getPreferredButtonSize(AbstractButton b,
                                                  int textIconGap)
   {
-    Rectangle contentRect;
-    Rectangle viewRect;
-    Rectangle iconRect = new Rectangle();
-    Rectangle textRect = new Rectangle();
-    Insets insets = b.getInsets();
-    
-    viewRect = new Rectangle();
-
-     /* java.awt.Toolkit.getFontMetrics is deprecated. However, it
-     * seems not obvious how to get to the correct FontMetrics object
-     * otherwise. The real problem probably is that the method
-     * javax.swing.SwingUtilities.layoutCompundLabel should take a
-     * LineMetrics, not a FontMetrics argument. But fixing this that
-     * would change the public API.
-     */
+    // These cached rectangles are use here and in BasicButtonUI.paint(),
+    // so these two methods must never be executed concurrently. Maybe
+    // we must use other Rectangle instances here. OTOH, Swing is
+    // designed to be not thread safe, and every layout and paint operation
+    // should be performed from the EventDispatchThread, so it _should_ be
+    // OK to do this optimization.
+    Rectangle viewRect = BasicButtonUI.viewR;
+    viewRect.x = 0;
+    viewRect.y = 0;
+    viewRect.width = Short.MAX_VALUE;
+    viewRect.height = Short.MAX_VALUE;
+    Rectangle iconRect = BasicButtonUI.iconR;
+    iconRect.x = 0;
+    iconRect.y = 0;
+    iconRect.width = 0;
+    iconRect.height = 0;
+    Rectangle textRect = BasicButtonUI.textR;
+    textRect.x = 0;
+    textRect.y = 0;
+    textRect.width = 0;
+    textRect.height = 0;
+
    SwingUtilities.layoutCompoundLabel(
       b, // for the component orientation
-      b.getToolkit().getFontMetrics(b.getFont()), // see comment above
+      b.getFontMetrics(b.getFont()), // see comment above
       b.getText(),
       b.getIcon(),
       b.getVerticalAlignment(), 
@@ -804,13 +810,12 @@ public class BasicGraphicsUtils
      *  +------------------------+       +------------------------+
      */
 
-    contentRect = textRect.union(iconRect);
-    
-    return new Dimension(insets.left
-			 + contentRect.width 
-			 + insets.right + b.getHorizontalAlignment(),
-                         insets.top
-			 + contentRect.height 
-			 + insets.bottom);
+    Rectangle contentRect =
+      SwingUtilities.computeUnion(textRect.x, textRect.y, textRect.width,
+                                  textRect.height, iconRect);
+
+    Insets insets = b.getInsets();
+    return new Dimension(insets.left + contentRect.width + insets.right,
+                         insets.top + contentRect.height + insets.bottom);
   }
 }
diff --git a/javax/swing/plaf/basic/BasicLabelUI.java b/javax/swing/plaf/basic/BasicLabelUI.java
index 304e13ad7..1ec020b1c 100644
--- a/javax/swing/plaf/basic/BasicLabelUI.java
+++ b/javax/swing/plaf/basic/BasicLabelUI.java
@@ -119,13 +119,37 @@ public class BasicLabelUI extends LabelUI implements PropertyChangeListener
   {
     JLabel lab = (JLabel) c;
     Insets insets = lab.getInsets();
-    FontMetrics fm = lab.getFontMetrics(lab.getFont());
-    layoutCL(lab, fm, lab.getText(), lab.getIcon(), vr, ir, tr);
-    Rectangle cr = SwingUtilities.computeUnion(tr.x, tr.y, tr.width, tr.height,
-                                               ir);
-    return new Dimension(insets.left + cr.width + insets.right, insets.top
-        + cr.height + insets.bottom);
-
+    int insetsX = insets.left + insets.right;
+    int insetsY = insets.top + insets.bottom;
+    Icon icon = lab.getIcon();
+    String text = lab.getText();
+    Dimension ret;
+    if (icon == null && text == null)
+      ret = new Dimension(insetsX, insetsY);
+    else if (icon != null && text == null)
+      ret = new Dimension(icon.getIconWidth() + insetsX,
+                          icon.getIconHeight() + insetsY);
+    else
+      {
+        FontMetrics fm = lab.getFontMetrics(lab.getFont());
+        ir.x = 0;
+        ir.y = 0;
+        ir.width = 0;
+        ir.height = 0;
+        tr.x = 0;
+        tr.y = 0;
+        tr.width = 0;
+        tr.height = 0;
+        vr.x = 0;
+        vr.y = 0;
+        vr.width = Short.MAX_VALUE;
+        vr.height = Short.MAX_VALUE;
+        layoutCL(lab, fm, text, icon, vr, ir, tr);
+        Rectangle cr = SwingUtilities.computeUnion(tr.x, tr.y, tr.width,
+                                                   tr.height, ir);
+        ret = new Dimension(cr.width + insetsX, cr.height + insetsY);
+      }
+    return ret;
   }
 
   /**
@@ -166,13 +190,20 @@ public class BasicLabelUI extends LabelUI implements PropertyChangeListener
   {
     JLabel b = (JLabel) c;
     FontMetrics fm = g.getFontMetrics();
-    vr = SwingUtilities.calculateInnerArea(c, vr);
-
-    if (vr.width < 0)
-      vr.width = 0;
-    if (vr.height < 0)
-      vr.height = 0;
 
+    Insets i = c.getInsets();
+    vr.x = i.left;
+    vr.y = i.right;
+    vr.width = c.getWidth() - i.left + i.right;
+    vr.height = c.getHeight() - i.top + i.bottom;
+    ir.x = 0;
+    ir.y = 0;
+    ir.width = 0;
+    ir.height = 0;
+    tr.x = 0;
+    tr.y = 0;
+    tr.width = 0;
+    tr.height = 0;
     Icon icon = (b.isEnabled()) ? b.getIcon() : b.getDisabledIcon();
 
     String text = layoutCL(b, fm, b.getText(), icon, vr, ir, tr);
diff --git a/javax/swing/plaf/basic/BasicMenuItemUI.java b/javax/swing/plaf/basic/BasicMenuItemUI.java
index 6110aca66..85eefb9ee 100644
--- a/javax/swing/plaf/basic/BasicMenuItemUI.java
+++ b/javax/swing/plaf/basic/BasicMenuItemUI.java
@@ -449,6 +449,7 @@ public class BasicMenuItemUI extends MenuItemUI
 
     // Layout the menu item. The result gets stored in the rectangle
     // fields of this class.
+    resetRectangles(null);
     layoutMenuItem(m, accelText);
 
     // The union of the text and icon areas is the label area.
@@ -700,6 +701,8 @@ public class BasicMenuItemUI extends MenuItemUI
 
     // Layout menu item. The result gets stored in the rectangle fields
     // of this class.
+    resetRectangles(m);
+
     layoutMenuItem(m, accelText);
 
     // Paint the background.
@@ -1271,6 +1274,33 @@ public class BasicMenuItemUI extends MenuItemUI
   }
 
   /**
+   * Resets the cached layout rectangles. If <code>i</code> is not null, then
+   * the view rectangle is set to the inner area of the component, otherwise
+   * it is set to (0, 0, Short.MAX_VALUE, Short.MAX_VALUE), this is needed
+   * for layouting.
+   *
+   * @param i the component for which to initialize the rectangles
+   */
+  private void resetRectangles(JMenuItem i)
+  {
+    // Reset rectangles.
+    iconRect.setBounds(0, 0, 0, 0);
+    textRect.setBounds(0, 0, 0, 0);
+    accelRect.setBounds(0, 0, 0, 0);
+    checkIconRect.setBounds(0, 0, 0, 0);
+    arrowIconRect.setBounds(0, 0, 0, 0);
+    if (i == null)
+      viewRect.setBounds(0, 0, Short.MAX_VALUE, Short.MAX_VALUE);
+    else
+      {
+        Insets insets = i.getInsets();
+        viewRect.setBounds(insets.left, insets.top,
+                           i.getWidth() - insets.left - insets.right,
+                           i.getHeight() - insets.top - insets.bottom);
+      }
+  }
+
+  /**
    * A helper method that lays out the menu item. The layout is stored
    * in the fields of this class.
    *
@@ -1282,21 +1312,6 @@ public class BasicMenuItemUI extends MenuItemUI
     int width = m.getWidth();
     int height = m.getHeight();
 
-    // Reset rectangles.
-    iconRect.setBounds(0, 0, 0, 0);
-    textRect.setBounds(0, 0, 0, 0);
-    accelRect.setBounds(0, 0, 0, 0);
-    checkIconRect.setBounds(0, 0, 0, 0);
-    arrowIconRect.setBounds(0, 0, 0, 0);
-    viewRect.setBounds(0, 0, width, height);
-
-    // Substract insets to the view rect.
-    Insets insets = m.getInsets();
-    viewRect.x += insets.left;
-    viewRect.y += insets.top;
-    viewRect.width -= insets.left + insets.right;
-    viewRect.height -= insets.top + insets.bottom;
-
     // Fetch the fonts.
     Font font = m.getFont();
     FontMetrics fm = m.getFontMetrics(font);
diff --git a/javax/swing/plaf/basic/BasicRadioButtonUI.java b/javax/swing/plaf/basic/BasicRadioButtonUI.java
index aed4d69d6..802b25339 100644
--- a/javax/swing/plaf/basic/BasicRadioButtonUI.java
+++ b/javax/swing/plaf/basic/BasicRadioButtonUI.java
@@ -129,9 +129,22 @@ public class BasicRadioButtonUI extends BasicToggleButtonUI
   {
     AbstractButton b = (AbstractButton) c;
 
-    Rectangle tr = new Rectangle();
-    Rectangle ir = new Rectangle();
-    Rectangle vr = new Rectangle();
+    Insets i = b.getInsets();
+    Rectangle tr = textR;
+    textR.x = 0;
+    textR.y = 0;
+    textR.width = 0;
+    textR.height = 0;
+    Rectangle ir = iconR;
+    iconR.x = 0;
+    iconR.y = 0;
+    iconR.width = 0;
+    iconR.height = 0;
+    Rectangle vr = viewR;
+    viewR.x = i.left;
+    viewR.y = i.right;
+    viewR.width = b.getWidth() - i.left - i.right;
+    viewR.height = b.getHeight() - i.top - i.bottom;
 
     Font f = c.getFont();
 
@@ -149,13 +162,12 @@ public class BasicRadioButtonUI extends BasicToggleButtonUI
         currentIcon = getDefaultIcon();
       }
     
-    SwingUtilities.calculateInnerArea(b, vr);
     String text = SwingUtilities.layoutCompoundLabel(c, g.getFontMetrics(f), 
        b.getText(), currentIcon,
        b.getVerticalAlignment(), b.getHorizontalAlignment(),
        b.getVerticalTextPosition(), b.getHorizontalTextPosition(),
        vr, ir, tr, b.getIconTextGap() + defaultTextShiftOffset);
-    
+
     currentIcon.paintIcon(c, g, ir.x, ir.y);
     
     if (text != null)
@@ -174,17 +186,25 @@ public class BasicRadioButtonUI extends BasicToggleButtonUI
     // The other icon properties are ignored.
     AbstractButton b = (AbstractButton) c;
     
-    Rectangle contentRect;
-    Rectangle viewRect;
-    Rectangle iconRect = new Rectangle();
-    Rectangle textRect = new Rectangle();
     Insets insets = b.getInsets();
-    
+
+    String text = b.getText();
     Icon i = b.getIcon();
     if (i == null)
       i = getDefaultIcon(); 
     
-    viewRect = new Rectangle();
+    textR.x = 0;
+    textR.y = 0;
+    textR.width = 0;
+    textR.height = 0;
+    iconR.x = 0;
+    iconR.y = 0;
+    iconR.width = 0;
+    iconR.height = 0;
+    viewR.x = 0;
+    viewR.y = 0;
+    viewR.width = Short.MAX_VALUE;
+    viewR.height = Short.MAX_VALUE;
 
     SwingUtilities.layoutCompoundLabel(
       b, // for the component orientation
@@ -195,17 +215,14 @@ public class BasicRadioButtonUI extends BasicToggleButtonUI
       b.getHorizontalAlignment(),
       b.getVerticalTextPosition(),
       b.getHorizontalTextPosition(),
-      viewRect, iconRect, textRect,
+      viewR, iconR, textR,
       defaultTextIconGap + defaultTextShiftOffset);
 
-    contentRect = textRect.union(iconRect);
-    
-    return new Dimension(insets.left
-                         + contentRect.width 
-                         + insets.right + b.getHorizontalAlignment(),
-                         insets.top
-                         + contentRect.height 
-                         + insets.bottom);
+    Rectangle r = SwingUtilities.computeUnion(textR.x, textR.y, textR.width,
+                                              textR.height, iconR);
+
+    return new Dimension(insets.left + r.width + insets.right,
+                         insets.top + r.height + insets.bottom);
   }
 
   /**