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, 1404 insertions, 0 deletions

diff --git a/libjava/classpath/javax/swing/plaf/basic/BasicOptionPaneUI.java b/libjava/classpath/javax/swing/plaf/basic/BasicOptionPaneUI.java
new file mode 100644
index 000000000..a03d224d2
--- /dev/null
+++ b/libjava/classpath/javax/swing/plaf/basic/BasicOptionPaneUI.java
@@ -0,0 +1,1404 @@
+/* BasicOptionPaneUI.java --
+   Copyright (C) 2004, 2005 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.plaf.basic;
+
+import java.awt.BorderLayout;
+import java.awt.Color;
+import java.awt.Component;
+import java.awt.Container;
+import java.awt.Dimension;
+import java.awt.Font;
+import java.awt.Graphics;
+import java.awt.GridBagConstraints;
+import java.awt.GridBagLayout;
+import java.awt.Insets;
+import java.awt.LayoutManager;
+import java.awt.Polygon;
+import java.awt.Window;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.beans.PropertyChangeEvent;
+import java.beans.PropertyChangeListener;
+import java.beans.PropertyVetoException;
+
+import javax.swing.AbstractAction;
+import javax.swing.Action;
+import javax.swing.ActionMap;
+import javax.swing.BorderFactory;
+import javax.swing.Box;
+import javax.swing.BoxLayout;
+import javax.swing.Icon;
+import javax.swing.InputMap;
+import javax.swing.JButton;
+import javax.swing.JComboBox;
+import javax.swing.JComponent;
+import javax.swing.JDialog;
+import javax.swing.JInternalFrame;
+import javax.swing.JLabel;
+import javax.swing.JList;
+import javax.swing.JOptionPane;
+import javax.swing.JPanel;
+import javax.swing.JTextField;
+import javax.swing.LookAndFeel;
+import javax.swing.SwingUtilities;
+import javax.swing.UIManager;
+import javax.swing.border.Border;
+import javax.swing.plaf.ActionMapUIResource;
+import javax.swing.plaf.ComponentUI;
+import javax.swing.plaf.OptionPaneUI;
+
+/**
+ * This class is the UI delegate for JOptionPane in the Basic Look and Feel.
+ */
+public class BasicOptionPaneUI extends OptionPaneUI
+{
+  /**
+   * Implements the "close" keyboard action.
+   */
+  static class OptionPaneCloseAction
+    extends AbstractAction
+  {
+
+    public void actionPerformed(ActionEvent event)
+    {
+      JOptionPane op = (JOptionPane) event.getSource();
+      op.setValue(new Integer(JOptionPane.CLOSED_OPTION));
+    }
+
+  }
+
+  /**
+   * This is a helper class that listens to the buttons located at the bottom
+   * of the JOptionPane.
+   *
+   * @specnote Apparently this class was intended to be protected,
+   *           but was made public by a compiler bug and is now
+   *           public for compatibility.
+   */
+  public class ButtonActionListener implements ActionListener
+  {
+    /** The index of the option this button represents. */
+    protected int buttonIndex;
+
+    /**
+     * Creates a new ButtonActionListener object with the given buttonIndex.
+     *
+     * @param buttonIndex The index of the option this button represents.
+     */
+    public ButtonActionListener(int buttonIndex)
+    {
+      this.buttonIndex = buttonIndex;
+    }
+
+    /**
+     * This method is called when one of the option buttons are pressed.
+     *
+     * @param e The ActionEvent.
+     */
+    public void actionPerformed(ActionEvent e)
+    {
+      Object value = new Integer(JOptionPane.CLOSED_OPTION);
+      Object[] options = optionPane.getOptions();
+      if (options != null)
+        value = new Integer(buttonIndex);
+      else
+        {
+          String text = ((JButton) e.getSource()).getText();
+          if (text.equals(OK_STRING))
+            value = new Integer(JOptionPane.OK_OPTION);
+          if (text.equals(CANCEL_STRING))
+            value = new Integer(JOptionPane.CANCEL_OPTION);
+          if (text.equals(YES_STRING))
+            value = new Integer(JOptionPane.YES_OPTION);
+          if (text.equals(NO_STRING))
+            value = new Integer(JOptionPane.NO_OPTION);
+        }
+      optionPane.setValue(value);
+      resetInputValue();
+
+      Window owner = SwingUtilities.windowForComponent(optionPane);
+
+      if (owner instanceof JDialog)
+        ((JDialog) owner).dispose();
+
+      //else we probably have some kind of internal frame.
+      JInternalFrame inf = (JInternalFrame) SwingUtilities.getAncestorOfClass(
+          JInternalFrame.class, optionPane);
+      if (inf != null)
+        {
+          try
+            {
+              inf.setClosed(true);
+            }
+          catch (PropertyVetoException pve)
+            {
+              // We do nothing if attempt has been vetoed.
+            }
+        }
+    }
+  }
+
+  /**
+   * This helper layout manager is responsible for the layout of the button
+   * area. The button area is the panel that holds the buttons which
+   * represent the options.
+   *
+   * @specnote Apparently this class was intended to be protected,
+   *           but was made public by a compiler bug and is now
+   *           public for compatibility.
+   */
+  public static class ButtonAreaLayout implements LayoutManager
+  {
+    /** Whether this layout will center the buttons. */
+    protected boolean centersChildren = true;
+
+    /** The space between the buttons. */
+    protected int padding;
+
+    /** Whether the buttons will share the same widths. */
+    protected boolean syncAllWidths;
+
+    /** The width of the widest button. */
+    private transient int widthOfWidestButton;
+
+    /** The height of the tallest button. */
+    private transient int tallestButton;
+
+    /**
+     * Creates a new ButtonAreaLayout object with the given sync widths
+     * property and padding.
+     *
+     * @param syncAllWidths Whether the buttons will share the same widths.
+     * @param padding The padding between the buttons.
+     */
+    public ButtonAreaLayout(boolean syncAllWidths, int padding)
+    {
+      this.syncAllWidths = syncAllWidths;
+      this.padding = padding;
+    }
+
+    /**
+     * This method is called when a component is added to the container.
+     *
+     * @param string The constraints string.
+     * @param comp The component added.
+     */
+    public void addLayoutComponent(String string, Component comp)
+    {
+      // Do nothing.
+    }
+
+    /**
+     * This method returns whether the children will be centered.
+     *
+     * @return Whether the children will be centered.
+     */
+    public boolean getCentersChildren()
+    {
+      return centersChildren;
+    }
+
+    /**
+     * This method returns the amount of space between components.
+     *
+     * @return The amount of space between components.
+     */
+    public int getPadding()
+    {
+      return padding;
+    }
+
+    /**
+     * This method returns whether all components will share widths (set to
+     * largest width).
+     *
+     * @return Whether all components will share widths.
+     */
+    public boolean getSyncAllWidths()
+    {
+      return syncAllWidths;
+    }
+
+    /**
+     * This method lays out the given container.
+     *
+     * @param container The container to lay out.
+     */
+    public void layoutContainer(Container container)
+    {
+      Component[] buttonList = container.getComponents();
+      int x = container.getInsets().left;
+      if (getCentersChildren())
+        x += (int) ((double) (container.getSize().width) / 2
+        - (double) (buttonRowLength(container)) / 2);
+      for (int i = 0; i < buttonList.length; i++)
+        {
+          Dimension dims = buttonList[i].getPreferredSize();
+          if (syncAllWidths)
+            {
+              buttonList[i].setBounds(x, 0, widthOfWidestButton, dims.height);
+              x += widthOfWidestButton + getPadding();
+            }
+          else
+            {
+              buttonList[i].setBounds(x, 0, dims.width, dims.height);
+              x += dims.width + getPadding();
+            }
+        }
+    }
+
+    /**
+     * This method returns the width of the given container taking into
+     * consideration the padding and syncAllWidths.
+     *
+     * @param c The container to calculate width for.
+     *
+     * @return The width of the given container.
+     */
+    private int buttonRowLength(Container c)
+    {
+      Component[] buttonList = c.getComponents();
+
+      int buttonLength = 0;
+      int widest = 0;
+      int tallest = 0;
+
+      for (int i = 0; i < buttonList.length; i++)
+        {
+          Dimension dims = buttonList[i].getPreferredSize();
+          buttonLength += dims.width + getPadding();
+          widest = Math.max(widest, dims.width);
+          tallest = Math.max(tallest, dims.height);
+        }
+
+      widthOfWidestButton = widest;
+      tallestButton = tallest;
+
+      int width;
+      if (getSyncAllWidths())
+        width = widest * buttonList.length
+                + getPadding() * (buttonList.length - 1);
+      else
+        width = buttonLength;
+
+      Insets insets = c.getInsets();
+      width += insets.left + insets.right;
+
+      return width;
+    }
+
+    /**
+     * This method returns the minimum layout size for the given container.
+     *
+     * @param c The container to measure.
+     *
+     * @return The minimum layout size.
+     */
+    public Dimension minimumLayoutSize(Container c)
+    {
+      return preferredLayoutSize(c);
+    }
+
+    /**
+     * This method returns the preferred size of the given container.
+     *
+     * @param c The container to measure.
+     *
+     * @return The preferred size.
+     */
+    public Dimension preferredLayoutSize(Container c)
+    {
+      int w = buttonRowLength(c);
+
+      return new Dimension(w, tallestButton);
+    }
+
+    /**
+     * This method removes the given component from the layout manager's
+     * knowledge.
+     *
+     * @param c The component to remove.
+     */
+    public void removeLayoutComponent(Component c)
+    {
+      // Do nothing.
+    }
+
+    /**
+     * This method sets whether the children will be centered.
+     *
+     * @param newValue Whether the children will be centered.
+     */
+    public void setCentersChildren(boolean newValue)
+    {
+      centersChildren = newValue;
+    }
+
+    /**
+     * This method sets the amount of space between each component.
+     *
+     * @param newPadding The padding between components.
+     */
+    public void setPadding(int newPadding)
+    {
+      padding = newPadding;
+    }
+
+    /**
+     * This method sets whether the widths will be synced.
+     *
+     * @param newValue Whether the widths will be synced.
+     */
+    public void setSyncAllWidths(boolean newValue)
+    {
+      syncAllWidths = newValue;
+    }
+  }
+
+  /**
+   * This helper class handles property change events from the JOptionPane.
+   *
+   * @specnote Apparently this class was intended to be protected,
+   *           but was made public by a compiler bug and is now
+   *           public for compatibility.
+   */
+  public class PropertyChangeHandler implements PropertyChangeListener
+  {
+    /**
+     * This method is called when one of the properties of the JOptionPane
+     * changes.
+     *
+     * @param e The PropertyChangeEvent.
+     */
+    public void propertyChange(PropertyChangeEvent e)
+    {
+      String property = e.getPropertyName();
+      if (property.equals(JOptionPane.ICON_PROPERTY)
+          || property.equals(JOptionPane.INITIAL_SELECTION_VALUE_PROPERTY)
+          || property.equals(JOptionPane.INITIAL_VALUE_PROPERTY)
+          || property.equals(JOptionPane.MESSAGE_PROPERTY)
+          || property.equals(JOptionPane.MESSAGE_TYPE_PROPERTY)
+          || property.equals(JOptionPane.OPTION_TYPE_PROPERTY)
+          || property.equals(JOptionPane.OPTIONS_PROPERTY)
+          || property.equals(JOptionPane.WANTS_INPUT_PROPERTY))
+        {
+          uninstallComponents();
+          installComponents();
+          optionPane.validate();
+        }
+    }
+  }
+
+  /**
+   * The minimum width for JOptionPanes.
+   */
+  public static final int MinimumWidth = 262;
+
+  /**
+   * The minimum height for JOptionPanes.
+   */
+  public static final int MinimumHeight = 90;
+
+  /** Whether the JOptionPane contains custom components. */
+  protected boolean hasCustomComponents;
+
+  // The initialFocusComponent seems to always be set to a button (even if
+  // I try to set initialSelectionValue). This is different from what the
+  // javadocs state (which should switch this reference to the input component
+  // if one is present since that is what's going to get focus).
+
+  /**
+   * The button that will receive focus based on initialValue when no input
+   * component is present. If an input component is present, then the input
+   * component will receive focus instead.
+   */
+  protected Component initialFocusComponent;
+
+  /** The component that receives input when the JOptionPane needs it. */
+  protected JComponent inputComponent;
+
+  /** The minimum dimensions of the JOptionPane. */
+  protected Dimension minimumSize;
+
+  /** The propertyChangeListener for the JOptionPane. */
+  protected PropertyChangeListener propertyChangeListener;
+
+  /** The JOptionPane this UI delegate is used for. */
+  protected JOptionPane optionPane;
+
+  /** The size of the icons. */
+  private static final int ICON_SIZE = 36;
+
+  /** The string used to describe OK buttons. */
+  private static final String OK_STRING = "OK";
+
+  /** The string used to describe Yes buttons. */
+  private static final String YES_STRING = "Yes";
+
+  /** The string used to describe No buttons. */
+  private static final String NO_STRING = "No";
+
+  /** The string used to describe Cancel buttons. */
+  private static final String CANCEL_STRING = "Cancel";
+
+  /** The container for the message area.
+   * This is package-private to avoid an accessor method. */
+  transient Container messageAreaContainer;
+
+  /** The container for the buttons.
+   * This is package-private to avoid an accessor method.  */
+  transient Container buttonContainer;
+
+  /**
+   * A helper class that implements Icon. This is used temporarily until
+   * ImageIcons are fixed.
+   */
+  private static class MessageIcon implements Icon
+  {
+    /**
+     * This method returns the width of the icon.
+     *
+     * @return The width of the icon.
+     */
+    public int getIconWidth()
+    {
+      return ICON_SIZE;
+    }
+
+    /**
+     * This method returns the height of the icon.
+     *
+     * @return The height of the icon.
+     */
+    public int getIconHeight()
+    {
+      return ICON_SIZE;
+    }
+
+    /**
+     * This method paints the icon as a part of the given component using the
+     * given graphics and the given x and y position.
+     *
+     * @param c The component that owns this icon.
+     * @param g The Graphics object to paint with.
+     * @param x The x coordinate.
+     * @param y The y coordinate.
+     */
+    public void paintIcon(Component c, Graphics g, int x, int y)
+    {
+      // Nothing to do here.
+    }
+  }
+
+  /** The icon displayed for ERROR_MESSAGE. */
+  private static MessageIcon errorIcon = new MessageIcon()
+    {
+      public void paintIcon(Component c, Graphics g, int x, int y)
+      {
+        Polygon oct = new Polygon(new int[] { 0, 0, 9, 27, 36, 36, 27, 9 },
+                                  new int[] { 9, 27, 36, 36, 27, 9, 0, 0 }, 8);
+        g.translate(x, y);
+
+        Color saved = g.getColor();
+        g.setColor(Color.RED);
+
+        g.fillPolygon(oct);
+
+        g.setColor(Color.BLACK);
+        g.drawRect(13, 16, 10, 4);
+
+        g.setColor(saved);
+        g.translate(-x, -y);
+      }
+    };
+
+  /** The icon displayed for INFORMATION_MESSAGE. */
+  private static MessageIcon infoIcon = new MessageIcon()
+    {
+      public void paintIcon(Component c, Graphics g, int x, int y)
+      {
+        g.translate(x, y);
+        Color saved = g.getColor();
+
+        // Should be purple.
+        g.setColor(Color.RED);
+
+        g.fillOval(0, 0, ICON_SIZE, ICON_SIZE);
+
+        g.setColor(Color.BLACK);
+        g.drawOval(16, 6, 4, 4);
+
+        Polygon bottomI = new Polygon(new int[] { 15, 15, 13, 13, 23, 23, 21, 21 },
+                                      new int[] { 12, 28, 28, 30, 30, 28, 28, 12 },
+                                      8);
+        g.drawPolygon(bottomI);
+
+        g.setColor(saved);
+        g.translate(-x, -y);
+      }
+    };
+
+  /** The icon displayed for WARNING_MESSAGE. */
+  private static MessageIcon warningIcon = new MessageIcon()
+    {
+      public void paintIcon(Component c, Graphics g, int x, int y)
+      {
+        g.translate(x, y);
+        Color saved = g.getColor();
+        g.setColor(Color.YELLOW);
+
+        Polygon triangle = new Polygon(new int[] { 0, 18, 36 },
+                                       new int[] { 36, 0, 36 }, 3);
+        g.fillPolygon(triangle);
+
+        g.setColor(Color.BLACK);
+
+        Polygon excl = new Polygon(new int[] { 15, 16, 20, 21 },
+                                   new int[] { 8, 26, 26, 8 }, 4);
+        g.drawPolygon(excl);
+        g.drawOval(16, 30, 4, 4);
+
+        g.setColor(saved);
+        g.translate(-x, -y);
+      }
+    };
+
+  /** The icon displayed for MESSAGE_ICON. */
+  private static MessageIcon questionIcon = new MessageIcon()
+    {
+      public void paintIcon(Component c, Graphics g, int x, int y)
+      {
+        g.translate(x, y);
+        Color saved = g.getColor();
+        g.setColor(Color.GREEN);
+
+        g.fillRect(0, 0, ICON_SIZE, ICON_SIZE);
+
+        g.setColor(Color.BLACK);
+
+        g.drawOval(11, 2, 16, 16);
+        g.drawOval(14, 5, 10, 10);
+
+        g.setColor(Color.GREEN);
+        g.fillRect(0, 10, ICON_SIZE, ICON_SIZE - 10);
+
+        g.setColor(Color.BLACK);
+
+        g.drawLine(11, 10, 14, 10);
+
+        g.drawLine(24, 10, 17, 22);
+        g.drawLine(27, 10, 20, 22);
+        g.drawLine(17, 22, 20, 22);
+
+        g.drawOval(17, 25, 3, 3);
+
+        g.setColor(saved);
+        g.translate(-x, -y);
+      }
+    };
+
+  /**
+   * Creates a new BasicOptionPaneUI object.
+   */
+  public BasicOptionPaneUI()
+  {
+    // Nothing to do here.
+  }
+
+  /**
+   * This method is messaged to add the buttons to the given container.
+   *
+   * @param container The container to add components to.
+   * @param buttons The buttons to add. (If it is an instance of component,
+   *        the Object is added directly. If it is an instance of Icon, it is
+   *        packed into a label and added. For all other cases, the string
+   *        representation of the Object is retreived and packed into a
+   *        label.)
+   * @param initialIndex The index of the component that is the initialValue.
+   */
+  protected void addButtonComponents(Container container, Object[] buttons,
+                                     int initialIndex)
+  {
+    if (buttons == null)
+      return;
+    for (int i = 0; i < buttons.length; i++)
+      {
+        if (buttons[i] != null)
+          {
+            Component toAdd;
+            if (buttons[i] instanceof Component)
+              toAdd = (Component) buttons[i];
+            else
+              {
+                if (buttons[i] instanceof Icon)
+                  toAdd = new JButton((Icon) buttons[i]);
+                else
+                  toAdd = new JButton(buttons[i].toString());
+                hasCustomComponents = true;
+              }
+            if (toAdd instanceof JButton)
+              ((JButton) toAdd).addActionListener(createButtonActionListener(i));
+            if (i == initialIndex)
+              initialFocusComponent = toAdd;
+            container.add(toAdd);
+          }
+      }
+    selectInitialValue(optionPane);
+  }
+
+  /**
+   * This method adds the appropriate icon the given container.
+   *
+   * @param top The container to add an icon to.
+   */
+  protected void addIcon(Container top)
+  {
+    JLabel iconLabel = null;
+    Icon icon = getIcon();
+    if (icon != null)
+      {
+        iconLabel = new JLabel(icon);
+        configureLabel(iconLabel);
+        top.add(iconLabel, BorderLayout.WEST);
+      }
+  }
+
+  /**
+   * A helper method that returns an instance of GridBagConstraints to be used
+   * for creating the message area.
+   *
+   * @return An instance of GridBagConstraints.
+   */
+  private static GridBagConstraints createConstraints()
+  {
+    GridBagConstraints constraints = new GridBagConstraints();
+    constraints.gridx = GridBagConstraints.REMAINDER;
+    constraints.gridy = GridBagConstraints.REMAINDER;
+    constraints.gridwidth = 0;
+    constraints.anchor = GridBagConstraints.LINE_START;
+    constraints.fill = GridBagConstraints.NONE;
+    constraints.insets = new Insets(0, 0, 3, 0);
+
+    return constraints;
+  }
+
+  /**
+   * This method creates the proper object (if necessary) to represent msg.
+   * (If msg is an instance of Component, it will add it directly. If it is
+   * an icon, then it will pack it in a label and add it. Otherwise, it gets
+   * treated as a string. If the string is longer than maxll, a box is
+   * created and the burstStringInto is called with the box as the container.
+   * The box is then added to the given container. Otherwise, the string is
+   * packed in a label and placed in the given container.) This method is
+   * also used for adding the inputComponent to the container.
+   *
+   * @param container The container to add to.
+   * @param cons The constraints when adding.
+   * @param msg The message to add.
+   * @param maxll The max line length.
+   * @param internallyCreated Whether the msg is internally created.
+   */
+  protected void addMessageComponents(Container container,
+                                      GridBagConstraints cons, Object msg,
+                                      int maxll, boolean internallyCreated)
+  {
+    if (msg == null)
+      return;
+    hasCustomComponents = internallyCreated;
+    if (msg instanceof Object[])
+      {
+        Object[] arr = (Object[]) msg;
+        for (int i = 0; i < arr.length; i++)
+          addMessageComponents(container, cons, arr[i], maxll,
+                               internallyCreated);
+        return;
+      }
+    else if (msg instanceof Component)
+      {
+        container.add((Component) msg, cons);
+        cons.gridy++;
+      }
+    else if (msg instanceof Icon)
+      {
+        JLabel label = new JLabel((Icon) msg);
+        configureLabel(label);
+        container.add(label, cons);
+        cons.gridy++;
+      }
+    else
+      {
+        // Undocumented behaviour.
+        // if msg.toString().length greater than maxll
+        // it will create a box and burst the string.
+        // otherwise, it will just create a label and re-call
+        // this method with the label o.O
+        if (msg.toString().length() > maxll || msg.toString().contains("\n"))
+          {
+            Box tmp = new Box(BoxLayout.Y_AXIS);
+            burstStringInto(tmp, msg.toString(), maxll);
+            addMessageComponents(container, cons, tmp, maxll, true);
+          }
+        else
+          {
+            JLabel label = new JLabel(msg.toString());
+            configureLabel(label);
+            addMessageComponents(container, cons, label, maxll, true);
+          }
+      }
+  }
+
+  /**
+   * This method creates instances of d (recursively if necessary based on
+   * maxll) and adds to c.
+   *
+   * @param c The container to add to.
+   * @param d The string to burst.
+   * @param maxll The max line length.
+   */
+  protected void burstStringInto(Container c, String d, int maxll)
+  {
+    if (d == null || c == null)
+      return;
+
+    int newlineIndex = d.indexOf('\n');
+    String line;
+    String remainder;
+    if (newlineIndex >= 0 && newlineIndex < maxll)
+      {
+        line = d.substring(0, newlineIndex);
+        remainder = d.substring(newlineIndex + 1);
+      }
+    else
+      {
+        line = d.substring(0, maxll);
+        remainder = d.substring(maxll);
+      }
+    JLabel label = new JLabel(line);
+    configureLabel(label);
+    c.add(label);
+
+    // If there is nothing left to burst, then we can stop.
+    if (remainder.length() == 0)
+      return;
+
+    // Recursively call ourselves to burst the remainder of the string,
+    if (remainder.length() > maxll || remainder.contains("\n"))
+      burstStringInto(c, remainder, maxll);
+    else
+      {
+        // Add the remainder to the container and be done.
+        JLabel l = new JLabel(remainder);
+        configureLabel(l);
+        c.add(l);
+      }
+  }
+
+  /**
+   * This method returns true if the given JOptionPane contains custom
+   * components.
+   *
+   * @param op The JOptionPane to check.
+   *
+   * @return True if the JOptionPane contains custom components.
+   */
+  public boolean containsCustomComponents(JOptionPane op)
+  {
+    return hasCustomComponents;
+  }
+
+  /**
+   * This method creates a button action listener for the given button index.
+   *
+   * @param buttonIndex The index of the button in components.
+   *
+   * @return A new ButtonActionListener.
+   */
+  protected ActionListener createButtonActionListener(int buttonIndex)
+  {
+    return new ButtonActionListener(buttonIndex);
+  }
+
+  /**
+   * This method creates the button area.
+   *
+   * @return A new Button Area.
+   */
+  protected Container createButtonArea()
+  {
+    JPanel buttonPanel = new JPanel();
+    Border b = UIManager.getBorder("OptionPane.buttonAreaBorder");
+    if (b != null)
+      buttonPanel.setBorder(b);
+
+    buttonPanel.setLayout(createLayoutManager());
+    addButtonComponents(buttonPanel, getButtons(), getInitialValueIndex());
+
+    return buttonPanel;
+  }
+
+  /**
+   * This method creates a new LayoutManager for the button area.
+   *
+   * @return A new LayoutManager for the button area.
+   */
+  protected LayoutManager createLayoutManager()
+  {
+    return new ButtonAreaLayout(getSizeButtonsToSameWidth(), 6);
+  }
+
+  /**
+   * This method creates the message area.
+   *
+   * @return A new message area.
+   */
+  protected Container createMessageArea()
+  {
+    JPanel messageArea = new JPanel();
+    Border messageBorder = UIManager.getBorder("OptionPane.messageAreaBorder");
+    if (messageBorder != null)
+      messageArea.setBorder(messageBorder);
+
+    messageArea.setLayout(new BorderLayout());
+    addIcon(messageArea);
+
+    JPanel rightSide = new JPanel();
+    rightSide.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));
+    rightSide.setLayout(new GridBagLayout());
+    GridBagConstraints con = createConstraints();
+
+    addMessageComponents(rightSide, con, getMessage(),
+                         getMaxCharactersPerLineCount(), false);
+
+    if (optionPane.getWantsInput())
+      {
+        Object[] selection = optionPane.getSelectionValues();
+
+        if (selection == null)
+          inputComponent = new JTextField(15);
+        else if (selection.length < 20)
+          inputComponent = new JComboBox(selection);
+        else
+          inputComponent = new JList(selection);
+        if (inputComponent != null)
+          {
+            addMessageComponents(rightSide, con, inputComponent,
+                                 getMaxCharactersPerLineCount(), false);
+            resetSelectedValue();
+            selectInitialValue(optionPane);
+          }
+      }
+
+    messageArea.add(rightSide, BorderLayout.CENTER);
+
+    return messageArea;
+  }
+
+  /**
+   * This method creates a new PropertyChangeListener for listening to the
+   * JOptionPane.
+   *
+   * @return A new PropertyChangeListener.
+   */
+  protected PropertyChangeListener createPropertyChangeListener()
+  {
+    return new PropertyChangeHandler();
+  }
+
+  /**
+   * This method creates a Container that will separate the message and button
+   * areas.
+   *
+   * @return A Container that will separate the message and button areas.
+   */
+  protected Container createSeparator()
+  {
+    // The reference implementation returns null here. When overriding
+    // to return something non-null, the component gets added between
+    // the message area and the button area. See installComponents().
+    return null;
+  }
+
+  /**
+   * This method creates a new BasicOptionPaneUI for the given component.
+   *
+   * @param x The component to create a UI for.
+   *
+   * @return A new BasicOptionPaneUI.
+   */
+  public static ComponentUI createUI(JComponent x)
+  {
+    return new BasicOptionPaneUI();
+  }
+
+  /**
+   * This method returns the buttons for the JOptionPane. If no options are
+   * set, a set of options will be created based upon the optionType.
+   *
+   * @return The buttons that will be added.
+   */
+  protected Object[] getButtons()
+  {
+    if (optionPane.getOptions() != null)
+      return optionPane.getOptions();
+    switch (optionPane.getOptionType())
+      {
+      case JOptionPane.YES_NO_OPTION:
+        return new Object[] { YES_STRING, NO_STRING };
+      case JOptionPane.YES_NO_CANCEL_OPTION:
+        return new Object[] { YES_STRING, NO_STRING, CANCEL_STRING };
+      case JOptionPane.OK_CANCEL_OPTION:
+        return new Object[] { OK_STRING, CANCEL_STRING };
+      case JOptionPane.DEFAULT_OPTION:
+        return (optionPane.getWantsInput()) ?
+               new Object[] { OK_STRING, CANCEL_STRING } :
+               (optionPane.getMessageType() == JOptionPane.QUESTION_MESSAGE) ?
+               new Object[] { YES_STRING, NO_STRING, CANCEL_STRING } :
+               // ERROR_MESSAGE, INFORMATION_MESSAGE, WARNING_MESSAGE, PLAIN_MESSAGE
+               new Object[] { OK_STRING };
+      }
+    return null;
+  }
+
+  /**
+   * This method will return the icon the user has set or the icon that will
+   * be used based on message type.
+   *
+   * @return The icon to use in the JOptionPane.
+   */
+  protected Icon getIcon()
+  {
+    if (optionPane.getIcon() != null)
+      return optionPane.getIcon();
+    else
+      return getIconForType(optionPane.getMessageType());
+  }
+
+  /**
+   * This method returns the icon for the given messageType.
+   *
+   * @param messageType The type of message.
+   *
+   * @return The icon for the given messageType.
+   */
+  protected Icon getIconForType(int messageType)
+  {
+    Icon tmp = null;
+    switch (messageType)
+      {
+      case JOptionPane.ERROR_MESSAGE:
+        tmp = errorIcon;
+        break;
+      case JOptionPane.INFORMATION_MESSAGE:
+        tmp = infoIcon;
+        break;
+      case JOptionPane.WARNING_MESSAGE:
+        tmp = warningIcon;
+        break;
+      case JOptionPane.QUESTION_MESSAGE:
+        tmp = questionIcon;
+        break;
+      }
+    return tmp;
+    // FIXME: Don't cast till the default icons are in.
+    // return new IconUIResource(tmp);
+  }
+
+  /**
+   * This method returns the index of the initialValue in the options array.
+   *
+   * @return The index of the initalValue.
+   */
+  protected int getInitialValueIndex()
+  {
+    Object[] buttons = getButtons();
+
+    if (buttons == null)
+      return -1;
+
+    Object select = optionPane.getInitialValue();
+
+    for (int i = 0; i < buttons.length; i++)
+      {
+        if (select == buttons[i])
+          return i;
+      }
+    return 0;
+  }
+
+  /**
+   * This method returns the maximum number of characters that should be
+   * placed on a line.
+   *
+   * @return The maximum number of characteres that should be placed on a
+   *         line.
+   */
+  protected int getMaxCharactersPerLineCount()
+  {
+    return optionPane.getMaxCharactersPerLineCount();
+  }
+
+  /**
+   * This method returns the maximum size.
+   *
+   * @param c The JComponent to measure.
+   *
+   * @return The maximum size.
+   */
+  public Dimension getMaximumSize(JComponent c)
+  {
+    return getPreferredSize(c);
+  }
+
+  /**
+   * This method returns the message of the JOptionPane.
+   *
+   * @return The message.
+   */
+  protected Object getMessage()
+  {
+    return optionPane.getMessage();
+  }
+
+  /**
+   * This method returns the minimum size of the JOptionPane.
+   *
+   * @return The minimum size.
+   */
+  public Dimension getMinimumOptionPaneSize()
+  {
+    return minimumSize;
+  }
+
+  /**
+   * This method returns the minimum size.
+   *
+   * @param c The JComponent to measure.
+   *
+   * @return The minimum size.
+   */
+  public Dimension getMinimumSize(JComponent c)
+  {
+    return getPreferredSize(c);
+  }
+
+  /**
+   * This method returns the preferred size of the JOptionPane. The preferred
+   * size is the maximum of the size desired by the layout and the minimum
+   * size.
+   *
+   * @param c The JComponent to measure.
+   *
+   * @return The preferred size.
+   */
+  public Dimension getPreferredSize(JComponent c)
+  {
+    Dimension d = optionPane.getLayout().preferredLayoutSize(optionPane);
+    Dimension d2 = getMinimumOptionPaneSize();
+
+    int w = Math.max(d.width, d2.width);
+    int h = Math.max(d.height, d2.height);
+    return new Dimension(w, h);
+  }
+
+  /**
+   * This method returns whether all buttons should have the same width.
+   *
+   * @return Whether all buttons should have the same width.
+   */
+  protected boolean getSizeButtonsToSameWidth()
+  {
+    return true;
+  }
+
+  /**
+   * This method installs components for the JOptionPane.
+   */
+  protected void installComponents()
+  {
+    // First thing is the message area.
+    optionPane.add(createMessageArea());
+
+    // Add separator when createSeparator() is overridden to return
+    // something other than null.
+    Container sep = createSeparator();
+    if (sep != null)
+      optionPane.add(sep);
+
+    // Last thing is the button area.
+    optionPane.add(createButtonArea());
+  }
+
+  /**
+   * This method installs defaults for the JOptionPane.
+   */
+  protected void installDefaults()
+  {
+    LookAndFeel.installColorsAndFont(optionPane, "OptionPane.background",
+                                     "OptionPane.foreground",
+                                     "OptionPane.font");
+    LookAndFeel.installBorder(optionPane, "OptionPane.border");
+    optionPane.setOpaque(true);
+
+    minimumSize = UIManager.getDimension("OptionPane.minimumSize");
+
+    // FIXME: Image icons don't seem to work properly right now.
+    // Once they do, replace the synthetic icons with these ones.
+
+    /*
+    warningIcon = (IconUIResource) defaults.getIcon("OptionPane.warningIcon");
+    infoIcon = (IconUIResource) defaults.getIcon("OptionPane.informationIcon");
+    errorIcon = (IconUIResource) defaults.getIcon("OptionPane.errorIcon");
+    questionIcon = (IconUIResource) defaults.getIcon("OptionPane.questionIcon");
+    */
+  }
+
+  /**
+   * This method installs keyboard actions for the JOptionpane.
+   */
+  protected void installKeyboardActions()
+  {
+    // Install the input map.
+    Object[] bindings =
+      (Object[]) SharedUIDefaults.get("OptionPane.windowBindings");
+    InputMap inputMap = LookAndFeel.makeComponentInputMap(optionPane,
+                                                          bindings);
+    SwingUtilities.replaceUIInputMap(optionPane,
+                                     JComponent.WHEN_IN_FOCUSED_WINDOW,
+                                     inputMap);
+
+    // FIXME: The JDK uses a LazyActionMap for parentActionMap
+    SwingUtilities.replaceUIActionMap(optionPane, getActionMap());
+  }
+
+  /**
+   * Fetches the action map from  the UI defaults, or create a new one
+   * if the action map hasn't been initialized.
+   *
+   * @return the action map
+   */
+  private ActionMap getActionMap()
+  {
+    ActionMap am = (ActionMap) UIManager.get("OptionPane.actionMap");
+    if (am == null)
+      {
+        am = createDefaultActions();
+        UIManager.getLookAndFeelDefaults().put("OptionPane.actionMap", am);
+      }
+    return am;
+  }
+
+  private ActionMap createDefaultActions()
+  {
+    ActionMapUIResource am = new ActionMapUIResource();
+    Action action = new OptionPaneCloseAction();
+
+    am.put("close", action);
+    return am;
+  }
+
+  /**
+   * This method installs listeners for the JOptionPane.
+   */
+  protected void installListeners()
+  {
+    propertyChangeListener = createPropertyChangeListener();
+
+    optionPane.addPropertyChangeListener(propertyChangeListener);
+  }
+
+  /**
+   * This method installs the UI for the JOptionPane.
+   *
+   * @param c The JComponent to install the UI for.
+   */
+  public void installUI(JComponent c)
+  {
+    if (c instanceof JOptionPane)
+      {
+        optionPane = (JOptionPane) c;
+
+        installDefaults();
+        installComponents();
+        installListeners();
+        installKeyboardActions();
+      }
+  }
+
+  /**
+   * Changes the inputValue property in the JOptionPane based on the current
+   * value of the inputComponent.
+   */
+  protected void resetInputValue()
+  {
+    if (optionPane.getWantsInput() && inputComponent != null)
+      {
+        Object output = null;
+        if (inputComponent instanceof JTextField)
+          output = ((JTextField) inputComponent).getText();
+        else if (inputComponent instanceof JComboBox)
+          output = ((JComboBox) inputComponent).getSelectedItem();
+        else if (inputComponent instanceof JList)
+          output = ((JList) inputComponent).getSelectedValue();
+
+        if (output != null)
+          optionPane.setInputValue(output);
+      }
+  }
+
+  /**
+   * This method requests focus to the inputComponent (if one is present) and
+   * the initialFocusComponent otherwise.
+   *
+   * @param op The JOptionPane.
+   */
+  public void selectInitialValue(JOptionPane op)
+  {
+    if (inputComponent != null)
+      {
+        inputComponent.requestFocus();
+        return;
+      }
+    if (initialFocusComponent != null)
+      initialFocusComponent.requestFocus();
+  }
+
+  /**
+   * This method resets the value in the inputComponent to the
+   * initialSelectionValue property.
+   * This is package-private to avoid an accessor method.
+   */
+  void resetSelectedValue()
+  {
+    if (inputComponent != null)
+      {
+        Object init = optionPane.getInitialSelectionValue();
+        if (init == null)
+          return;
+        if (inputComponent instanceof JTextField)
+          ((JTextField) inputComponent).setText((String) init);
+        else if (inputComponent instanceof JComboBox)
+          ((JComboBox) inputComponent).setSelectedItem(init);
+        else if (inputComponent instanceof JList)
+          {
+            //  ((JList) inputComponent).setSelectedValue(init, true);
+          }
+      }
+  }
+
+  /**
+   * This method uninstalls all the components in the JOptionPane.
+   */
+  protected void uninstallComponents()
+  {
+    optionPane.removeAll();
+    buttonContainer = null;
+    messageAreaContainer = null;
+  }
+
+  /**
+   * This method uninstalls the defaults for the JOptionPane.
+   */
+  protected void uninstallDefaults()
+  {
+    optionPane.setFont(null);
+    optionPane.setForeground(null);
+    optionPane.setBackground(null);
+
+    minimumSize = null;
+
+    // FIXME: ImageIcons don't seem to work properly
+
+    /*
+    warningIcon = null;
+    errorIcon = null;
+    questionIcon = null;
+    infoIcon = null;
+    */
+  }
+
+  /**
+   * This method uninstalls keyboard actions for the JOptionPane.
+   */
+  protected void uninstallKeyboardActions()
+  {
+    SwingUtilities.replaceUIInputMap(optionPane, JComponent.
+                                     WHEN_ANCESTOR_OF_FOCUSED_COMPONENT, null);
+    SwingUtilities.replaceUIActionMap(optionPane, null);
+  }
+
+  /**
+   * This method uninstalls listeners for the JOptionPane.
+   */
+  protected void uninstallListeners()
+  {
+    optionPane.removePropertyChangeListener(propertyChangeListener);
+    propertyChangeListener = null;
+  }
+
+  /**
+   * This method uninstalls the UI for the given JComponent.
+   *
+   * @param c The JComponent to uninstall for.
+   */
+  public void uninstallUI(JComponent c)
+  {
+    uninstallKeyboardActions();
+    uninstallListeners();
+    uninstallComponents();
+    uninstallDefaults();
+
+    optionPane = null;
+  }
+
+  /**
+   * Applies the proper UI configuration to labels that are added to
+   * the OptionPane.
+   *
+   * @param l the label to configure
+   */
+  private void configureLabel(JLabel l)
+  {
+    Color c = UIManager.getColor("OptionPane.messageForeground");
+    if (c != null)
+      l.setForeground(c);
+    Font f = UIManager.getFont("OptionPane.messageFont");
+    if (f != null)
+      l.setFont(f);
+  }
+}