/* 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);
  }
}