2004-09-04 Graydon Hoare <graydon@redhat.com>

        * javax/swing/JColorChooser.java:
        Make a couple inner classes static, for jikes.

2004-09-04  Kim Ho  <kho@redhat.com>

        * java/awt/Color.java: Fix documentation.
        (RGBtoHSB): Use floats for conversions.
        * javax/swing/ButtonGroup.java: Run Jalopy.
        (setSelected): Reimplement.
        * javax/swing/DefaultButtonModel.java: Run Jalopy.
        (changeState): Let ButtonGroup know that the button
        is changing state.
        * javax/swing/JColorChooser.java: Implement.
        * javax/swing/JLabel.java: Run Jalopy.
        * javax/swing/JSpinner.java: Run Jalopy.
        (setValue): New method.
        * javax/swing/JTabbedPane.java: Run Jalopy.
        (removeTabAt): Call correct remove method.
        * javax/swing/SpinnerNumberModel.java: Run Jalopy.
        (getPreviousValue): Compare minimum value.
        * javax/swing/Timer.java: Run Jalopy.
        (run): Comment out println.
        * javax/swing/ToolTipManager.java:
        (mouseMoved): Get new tooltip text for location.
        * javax/swing/colorchooser/AbstractColorChooserPanel.java:
        Jalopy and Javadoc.
        * javax/swing/colorchooser/ColorChooserComponentFactory.java:
        Implement.
        * javax/swing/colorchooser/DefaultColorSelectionModel.java:
        Run Jalopy.
        (setSelectedColor): Fire ChangeEvent.
        * javax/swing/colorchooser/DefaultHSBChooserPanel.java:
        New file. Implement.
        * javax/swing/colorchooser/DefaultPreviewPanel.java:
        Ditto.
        * javax/swing/colorchooser/DefaultRGBChooserPanel.java:
        Ditto.
        * javax/swing/colorchooser/DefaultSwatchChooserPanel.java:
        Ditto.
        * javax/swing/plaf/basic/BasicArrowButton.java:
        (getArrow): Fix size of upward pointing button.
        * javax/swing/plaf/basic/BasicColorChooserUI.java:
        Implement.
        * javax/swing/plaf/basic/BasicSliderUI.java:
        (getWidthOfWidestLabel): Use preferred dimensions.
        (getHeightOfTallestLabel): Ditto.
        * javax/swing/plaf/basic/BasicSpinnerUI.java:
        Run Jalopy.
        (mousePressed): Disable changes to spinner if it is not enabled.

4 files changed, 2445 insertions, 0 deletions

diff --git a/javax/swing/colorchooser/DefaultHSBChooserPanel.java b/javax/swing/colorchooser/DefaultHSBChooserPanel.java
new file mode 100644
index 000000000..dcd795a74
--- /dev/null
+++ b/javax/swing/colorchooser/DefaultHSBChooserPanel.java
@@ -0,0 +1,860 @@
+/* DefaultHSBChooserPanel.java --
+   Copyright (C) 2004 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., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 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.colorchooser;
+
+import java.awt.BorderLayout;
+import java.awt.Color;
+import java.awt.Component;
+import java.awt.ComponentOrientation;
+import java.awt.Container;
+import java.awt.Dimension;
+import java.awt.Graphics;
+import java.awt.GridLayout;
+import java.awt.Image;
+import java.awt.LayoutManager;
+import java.awt.Point;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+import java.awt.event.MouseMotionListener;
+import java.awt.image.MemoryImageSource;
+import javax.swing.AbstractButton;
+import javax.swing.ButtonGroup;
+import javax.swing.Icon;
+import javax.swing.JColorChooser;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.JRadioButton;
+import javax.swing.JSlider;
+import javax.swing.JSpinner;
+import javax.swing.SpinnerNumberModel;
+import javax.swing.SwingConstants;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+
+
+/**
+ * This is the Default HSB Panel displayed in the JColorChooser.
+ */
+class DefaultHSBChooserPanel extends AbstractColorChooserPanel
+{
+  /** The gradient image displayed. */
+  private transient Image gradientImage;
+
+  /** The Panel that holds the gradient image. */
+  private transient JPanel gradientPanel;
+
+  /** The track gradient image. */
+  private transient Image trackImage;
+
+  /** The panel that holds the track. */
+  private transient JPanel trackPanel;
+
+  /** The slider for the locked HSB value. */
+  private transient JSlider slider;
+
+  /** The RadioButton that controls the Hue. */
+  private transient JRadioButton hRadio;
+
+  /** The RadioButton that controls the Saturation. */
+  private transient JRadioButton sRadio;
+
+  /** The RadioButton that controls the Brightness. */
+  private transient JRadioButton bRadio;
+
+  /** The JSpinner that controls the Hue. */
+  private transient JSpinner hSpinner;
+
+  /** The JSpinner that controls the Saturation. */
+  private transient JSpinner sSpinner;
+
+  /** The JSpinner that controls the Brightness. */
+  private transient JSpinner bSpinner;
+
+  /** The default width of the gradient image. */
+  private static final int imgWidth = 200;
+
+  /** The default height of the gradient image. */
+  private static final int imgHeight = 200;
+
+  /** The default width of the track gradient. */
+  private static final int trackWidth = 30;
+
+  /** The JLabel for Red. */
+  private static final JLabel R = new JLabel("R");
+
+  /** The JLabel for Green. */
+  private static final JLabel G = new JLabel("G");
+
+  /** The JLabel for Blue. */
+  private static final JLabel B = new JLabel("B");
+
+  // FIXME: Should be textfields.
+
+  /** The JLabel that displays the value of Red. */
+  private transient JLabel rFull;
+
+  /** The JLabel that displays the value of Green. */
+  private transient JLabel gFull;
+
+  /** The JLabel that displays the value of Blue. */
+  private transient JLabel bFull;
+
+  /** The point that is displayed in the gradient image. */
+  private transient Point gradientPoint = new Point();
+
+  /**
+   * This indicates that the change to the slider or point is triggered
+   * internally.
+   */
+  private transient boolean internalChange = false;
+
+  /** This indicates that the change to the spinner is triggered internally. */
+  private transient boolean spinnerTrigger = false;
+
+  /** This int identifies which spinner is currently locked. */
+  private transient int locked = -1;
+
+  /** This value indicates that the Hue spinner is locked. */
+  static final int HLOCKED = 0;
+
+  /** This value indicates that the Saturation spinner is locked. */
+  static final int SLOCKED = 1;
+
+  /** This value indicates that the Brightness spinner is locked. */
+  static final int BLOCKED = 2;
+
+  /**
+   * This method indicates that the mouse event is in the process of being
+   * handled.
+   */
+  private transient boolean handlingMouse;
+
+  /**
+   * This helper class handles mouse events on the gradient image.
+   */
+  class MainGradientMouseListener extends MouseAdapter
+    implements MouseMotionListener
+  {
+    /**
+     * This method is called when the mouse is pressed over the gradient
+     * image. The JColorChooser is then updated with new HSB values.
+     *
+     * @param e The MouseEvent.
+     */
+    public void mousePressed(MouseEvent e)
+    {
+      gradientPoint = e.getPoint();
+      update(e.getPoint());
+    }
+
+    /**
+     * This method is called when the mouse is dragged over the gradient
+     * image. The JColorChooser is then updated with the new HSB values.
+     *
+     * @param e The MouseEvent.
+     */
+    public void mouseDragged(MouseEvent e)
+    {
+      Point p = e.getPoint();
+      if (p.x < 0 || p.y < 0 || p.y > imgHeight || p.x > imgWidth)
+	return;
+
+      gradientPoint = p;
+      update(p);
+    }
+
+    /**
+     * This method is called when the mouse is moved over the gradient image.
+     *
+     * @param e The MouseEvent.
+     */
+    public void mouseMoved(MouseEvent e)
+    {
+      // Do nothing.
+    }
+
+    /**
+     * This method updates the JColorChooser with the new values.
+     *
+     * @param p The Point where the MouseEvent occurred.
+     */
+    private void update(Point p)
+    {
+      handlingMouse = true;
+      if (hSpinner.isEnabled())
+	updateH(p);
+      else if (sSpinner.isEnabled())
+	updateS(p);
+      else
+	updateB(p);
+      handlingMouse = false;
+    }
+
+    /**
+     * This method updates the SB values if Hue is locked.
+     *
+     * @param p The point where the MouseEvent occurred.
+     */
+    private void updateH(Point p)
+    {
+      float s = (imgWidth - p.x * 1f) / imgWidth;
+      float b = (imgHeight - p.y * 1f) / imgHeight;
+
+      // Avoid two changes to the model by changing internalChange to true.
+      internalChange = true;
+      sSpinner.setValue(new Integer((int) (s * 100)));
+      internalChange = false;
+      bSpinner.setValue(new Integer((int) (b * 100)));
+
+      revalidate();
+    }
+
+    /**
+     * This method updates the HB values if Saturation is locked.
+     *
+     * @param p The point where the MouseEvent occurred.
+     */
+    private void updateS(Point p)
+    {
+      float h = p.x * 1f / imgWidth;
+      float b = (imgHeight - p.y * 1f) / imgHeight;
+
+      internalChange = true;
+      hSpinner.setValue(new Integer((int) (h * 365)));
+      internalChange = false;
+      bSpinner.setValue(new Integer((int) (b * 100)));
+
+      revalidate();
+    }
+
+    /**
+     * This method updates the HS values if Brightness is locked.
+     *
+     * @param p The point where the MouseEvent occurred.
+     */
+    private void updateB(Point p)
+    {
+      float h = p.x * 1f / imgWidth;
+      float s = (imgHeight - p.y * 1f) / imgHeight;
+
+      internalChange = true;
+      hSpinner.setValue(new Integer((int) (h * 365)));
+      internalChange = false;
+      sSpinner.setValue(new Integer((int) (s * 100)));
+
+      revalidate();
+    }
+  }
+
+  /**
+   * This method listens for slider value changes.
+   */
+  class SliderChangeListener implements ChangeListener
+  {
+    /**
+     * This method is called when the slider value changes. It should change
+     * the color of the JColorChooser.
+     *
+     * @param e The ChangeEvent.
+     */
+    public void stateChanged(ChangeEvent e)
+    {
+      if (internalChange)
+	return;
+
+      Integer value = new Integer(slider.getValue());
+
+      switch (locked)
+        {
+	case HLOCKED:
+	  hSpinner.setValue(value);
+	  break;
+	case SLOCKED:
+	  sSpinner.setValue(value);
+	  break;
+	case BLOCKED:
+	  bSpinner.setValue(value);
+	  break;
+        }
+    }
+  }
+
+  /**
+   * This helper class determines the active JSpinner.
+   */
+  class RadioStateListener implements ChangeListener
+  {
+    /**
+     * This method is called when there is a new JRadioButton that was
+     * selected. As a result, it should activate the associated JSpinner.
+     *
+     * @param e The ChangeEvent.
+     */
+    public void stateChanged(ChangeEvent e)
+    {
+      JSpinner change;
+      if (e.getSource() == hRadio)
+        {
+	  locked = HLOCKED;
+	  change = hSpinner;
+        }
+      else if (e.getSource() == sRadio)
+        {
+	  locked = SLOCKED;
+	  change = sSpinner;
+        }
+      else
+        {
+	  locked = BLOCKED;
+	  change = bSpinner;
+        }
+
+      change.setEnabled(((AbstractButton) e.getSource()).isSelected());
+      updateSlider();
+      updateTrack();
+      updateImage();
+      repaint();
+    }
+  }
+
+  /**
+   * This class listens to the JSpinners for changes.
+   */
+  class ImageScrollListener implements ChangeListener
+  {
+    /**
+     * This method is called whenever one of the JSpinner values change. The
+     * JColorChooser should be updated with the new HSB values.
+     *
+     * @param e The ChangeEvent.
+     */
+    public void stateChanged(ChangeEvent e)
+    {
+      if (internalChange)
+	return;
+
+      float h = ((Number) hSpinner.getValue()).intValue() / 360f;
+      float s = ((Number) sSpinner.getValue()).intValue() / 100f;
+      float b = ((Number) bSpinner.getValue()).intValue() / 100f;
+
+      spinnerTrigger = true;
+      getColorSelectionModel().setSelectedColor(new Color(Color.HSBtoRGB(h, s,
+                                                                         b)));
+      spinnerTrigger = false;
+
+      if (! handlingMouse)
+        {
+	  updateImage();
+	  updateTrack();
+        }
+      repaint();
+    }
+  }
+
+  /**
+   * Creates a new DefaultHSBChooserPanel object.
+   */
+  DefaultHSBChooserPanel()
+  {
+    super();
+  }
+
+  /**
+   * This method returns the name displayed by the JColorChooser tab that
+   * holds this panel.
+   *
+   * @return The name displayed in the JColorChooser tab.
+   */
+  public String getDisplayName()
+  {
+    return "HSB";
+  }
+
+  /**
+   * This method updates the various components inside the HSBPanel (the
+   * JSpinners, the JSlider, and the gradient image point) with updated
+   * values when the JColorChooser color value changes.
+   */
+  public void updateChooser()
+  {
+    Color c = getColorSelectionModel().getSelectedColor();
+
+    float[] hsbVals = Color.RGBtoHSB(c.getRed(), c.getGreen(), c.getBlue(),
+                                     null);
+
+    internalChange = true;
+
+    // spinnerTrigger, internalChange, and handlingMouse are used because of the
+    // we don't want things like: change spinner -> update chooser -> change spinner
+    // That's because the value from before and after the update can differ
+    // slightly because of the conversion.
+    // FIXME: Think of better way to deal with this.
+    if (! spinnerTrigger)
+      {
+	hSpinner.setValue(new Integer((int) (hsbVals[0] * 360)));
+	sSpinner.setValue(new Integer((int) (hsbVals[1] * 100)));
+	bSpinner.setValue(new Integer((int) (hsbVals[2] * 100)));
+      }
+
+    switch (locked)
+      {
+      case HLOCKED:
+	if (slider != null)
+	  slider.setValue(((Number) hSpinner.getValue()).intValue());
+	if (! handlingMouse)
+	  {
+	    gradientPoint.x = (int) ((1 - hsbVals[1]) * imgWidth);
+	    gradientPoint.y = (int) ((1 - hsbVals[2]) * imgHeight);
+	  }
+	break;
+      case SLOCKED:
+	if (slider != null)
+	  slider.setValue(((Number) sSpinner.getValue()).intValue());
+	if (! handlingMouse)
+	  {
+	    gradientPoint.x = (int) (hsbVals[0] * imgWidth);
+	    gradientPoint.y = (int) ((1 - hsbVals[2]) * imgHeight);
+	  }
+	break;
+      case BLOCKED:
+	if (slider != null)
+	  slider.setValue(((Number) bSpinner.getValue()).intValue());
+	if (! handlingMouse)
+	  {
+	    gradientPoint.x = (int) (hsbVals[0] * imgWidth);
+	    gradientPoint.y = (int) ((1 - hsbVals[1]) * imgHeight);
+	  }
+	break;
+      }
+    internalChange = false;
+
+    updateImage();
+    updateTrack();
+    updateTextFields();
+  }
+
+  /**
+   * This method builds the DefaultHSBChooserPanel.
+   */
+  protected void buildChooser()
+  {
+    setLayout(new BorderLayout());
+
+    add(buildRightPanel(), BorderLayout.EAST);
+
+    JPanel container = new JPanel();
+    container.setLayout(new BorderLayout());
+
+    gradientPanel = new JPanel()
+        {
+	  public Dimension getPreferredSize()
+	  {
+	    return new Dimension(imgWidth, imgHeight);
+	  }
+
+	  public void paint(Graphics g)
+	  {
+	    if (gradientImage != null)
+	      g.drawImage(gradientImage, 0, 0, this);
+
+	    Color saved = g.getColor();
+	    g.setColor(Color.WHITE);
+	    g.drawOval(gradientPoint.x - 3, gradientPoint.y - 3, 6, 6);
+	    g.setColor(saved);
+	  }
+        };
+
+    MouseAdapter ml = new MainGradientMouseListener();
+    gradientPanel.addMouseListener(ml);
+    gradientPanel.addMouseMotionListener((MouseMotionListener) ml);
+
+    trackPanel = new JPanel()
+        {
+	  public Dimension getPreferredSize()
+	  {
+	    return new Dimension(trackWidth, imgHeight);
+	  }
+
+	  public void paint(Graphics g)
+	  {
+	    if (trackImage != null)
+	      g.drawImage(trackImage, 0, 0, this);
+	  }
+        };
+
+    slider = new JSlider();
+    slider.setPaintTrack(false);
+    slider.setPaintTicks(false);
+
+    slider.setOrientation(SwingConstants.VERTICAL);
+
+    updateSlider();
+
+    container.add(gradientPanel, BorderLayout.WEST);
+    container.add(slider, BorderLayout.CENTER);
+    container.add(trackPanel, BorderLayout.EAST);
+
+    add(container, BorderLayout.WEST);
+    slider.addChangeListener(new SliderChangeListener());
+    repaint();
+  }
+
+  /**
+   * This method uninstalls the DefaultHSBPanel.
+   *
+   * @param chooser The JColorChooser to remove this panel from.
+   */
+  public void uninstallChooserPanel(JColorChooser chooser)
+  {
+    trackImage = null;
+    gradientImage = null;
+    gradientPanel = null;
+    slider = null;
+
+    hSpinner = null;
+    sSpinner = null;
+    bSpinner = null;
+
+    hRadio = null;
+    sRadio = null;
+    bRadio = null;
+
+    removeAll();
+    super.uninstallChooserPanel(chooser);
+  }
+
+  /**
+   * This helper method creates the right side panel (the panel with the
+   * Spinners and TextFields).
+   *
+   * @return The right side panel.
+   */
+  private Container buildRightPanel()
+  {
+    JPanel container = new JPanel();
+    container.setLayout(new GridLayout(6, 2));
+
+    hRadio = new JRadioButton("H");
+    sRadio = new JRadioButton("S");
+    bRadio = new JRadioButton("B");
+
+    ButtonGroup group = new ButtonGroup();
+    group.add(hRadio);
+    group.add(sRadio);
+    group.add(bRadio);
+
+    hSpinner = new JSpinner(new SpinnerNumberModel(0, 0, 359, 1));
+    sSpinner = new JSpinner(new SpinnerNumberModel(0, 0, 100, 1));
+    bSpinner = new JSpinner(new SpinnerNumberModel(100, 0, 100, 1));
+
+    hSpinner.setEnabled(false);
+    sSpinner.setEnabled(false);
+    bSpinner.setEnabled(false);
+
+    ChangeListener cl = new RadioStateListener();
+    ChangeListener scroll = new ImageScrollListener();
+
+    hRadio.addChangeListener(cl);
+    sRadio.addChangeListener(cl);
+    bRadio.addChangeListener(cl);
+
+    hSpinner.addChangeListener(scroll);
+    sSpinner.addChangeListener(scroll);
+    bSpinner.addChangeListener(scroll);
+
+    hRadio.setSelected(true);
+
+    container.add(hRadio);
+    container.add(hSpinner);
+
+    container.add(sRadio);
+    container.add(sSpinner);
+
+    container.add(bRadio);
+    container.add(bSpinner);
+
+    rFull = new JLabel("red full");
+    gFull = new JLabel("green full");
+    bFull = new JLabel("blue full");
+
+    container.add(R);
+    container.add(rFull);
+
+    container.add(G);
+    container.add(gFull);
+
+    container.add(B);
+    container.add(bFull);
+
+    return container;
+  }
+
+  /**
+   * This method returns the small display icon.
+   *
+   * @return The small display icon.
+   */
+  public Icon getSmallDisplayIcon()
+  {
+    return null;
+  }
+
+  /**
+   * This method returns the large display icon.
+   *
+   * @return The large display icon.
+   */
+  public Icon getLargeDisplayIcon()
+  {
+    return null;
+  }
+
+  /**
+   * This method paints the chooser panel.
+   *
+   * @param g The graphics object to paint with.
+   */
+  public void paint(Graphics g)
+  {
+    super.paint(g);
+  }
+
+  /**
+   * This method updates the gradient image with a new one taking the Hue
+   * value as the constant.
+   */
+  private void updateHLockImage()
+  {
+    int index = 0;
+    int[] pix = new int[imgWidth * imgHeight];
+    float hValue = ((Number) hSpinner.getValue()).intValue() / 360f;
+
+    for (int j = 0; j < imgHeight; j++)
+      for (int i = 0; i < imgWidth; i++)
+	pix[index++] = Color.HSBtoRGB(hValue, (imgWidth - i * 1f) / imgWidth,
+	                              (imgHeight - j * 1f) / imgHeight)
+	               | (255 << 24);
+
+    gradientImage = createImage(new MemoryImageSource(imgWidth, imgHeight,
+                                                      pix, 0, imgWidth));
+  }
+
+  /**
+   * This method updates the gradient image with a new one taking the
+   * Brightness value as the constant.
+   */
+  private void updateBLockImage()
+  {
+    int[] pix = new int[imgWidth * imgHeight];
+    float bValue = ((Number) bSpinner.getValue()).intValue() / 100f;
+
+    int index = 0;
+    for (int j = 0; j < imgHeight; j++)
+      for (int i = 0; i < imgWidth; i++)
+	pix[index++] = Color.HSBtoRGB(i * 1f / imgWidth,
+	                              (imgHeight - j * 1f) / imgHeight, bValue)
+	               | (255 << 24);
+
+    gradientImage = createImage(new MemoryImageSource(imgWidth, imgHeight,
+                                                      pix, 0, imgWidth));
+  }
+
+  /**
+   * This method updates the gradient image with a new one taking the
+   * Saturation value as the constant.
+   */
+  private void updateSLockImage()
+  {
+    int[] pix = new int[imgWidth * imgHeight];
+    float sValue = ((Number) sSpinner.getValue()).intValue() / 100f;
+
+    int index = 0;
+    for (int j = 0; j < imgHeight; j++)
+      for (int i = 0; i < imgWidth; i++)
+	pix[index++] = Color.HSBtoRGB(i * 1f / imgWidth, sValue,
+	                              (imgHeight - j * 1f) / imgHeight)
+	               | (255 << 24);
+    gradientImage = createImage(new MemoryImageSource(imgWidth, imgHeight,
+                                                      pix, 0, imgWidth));
+  }
+
+  /**
+   * This method calls the appropriate method to update the gradient image
+   * depending on which HSB value is constant.
+   */
+  private void updateImage()
+  {
+    switch (locked)
+      {
+      case HLOCKED:
+	updateHLockImage();
+	break;
+      case SLOCKED:
+	updateSLockImage();
+	break;
+      case BLOCKED:
+	updateBLockImage();
+	break;
+      }
+  }
+
+  /**
+   * This method updates the TextFields with the correct RGB values.
+   */
+  private void updateTextFields()
+  {
+    int c = getColorSelectionModel().getSelectedColor().getRGB();
+
+    rFull.setText("" + (c >> 16 & 0xff));
+    gFull.setText("" + (c >> 8 & 0xff));
+    bFull.setText("" + (c & 0xff));
+
+    repaint();
+  }
+
+  /**
+   * This method updates the slider in response to making a different HSB
+   * property the constant.
+   */
+  private void updateSlider()
+  {
+    if (slider == null)
+      return;
+
+    slider.setMinimum(0);
+    if (locked == HLOCKED)
+      {
+	slider.setMaximum(359);
+	;
+	slider.setValue(((Number) hSpinner.getValue()).intValue());
+	slider.setInverted(true);
+      }
+    else
+      {
+	slider.setMaximum(100);
+	slider.setInverted(false);
+	if (sRadio.isSelected())
+	  slider.setValue(((Number) sSpinner.getValue()).intValue());
+	else
+	  slider.setValue(((Number) bSpinner.getValue()).intValue());
+      }
+    repaint();
+  }
+
+  /**
+   * This method updates the track gradient image depending on which HSB
+   * property is constant.
+   */
+  private void updateTrack()
+  {
+    switch (locked)
+      {
+      case HLOCKED:
+	updateHTrack();
+	break;
+      case SLOCKED:
+	updateSTrack();
+	break;
+      case BLOCKED:
+	updateBTrack();
+	break;
+      }
+  }
+
+  /**
+   * This method updates the track gradient image if the Hue value is allowed
+   * to change (according to the JRadioButtons).
+   */
+  private void updateHTrack()
+  {
+    int trackIndex = 0;
+    int[] trackPix = new int[trackWidth * imgHeight];
+
+    for (int j = 0; j < imgHeight; j++)
+      for (int i = 0; i < trackWidth; i++)
+	trackPix[trackIndex++] = Color.HSBtoRGB(j * 1f / imgHeight, 1f, 1f)
+	                         | (255 << 24);
+
+    trackImage = createImage(new MemoryImageSource(trackWidth, imgHeight,
+                                                   trackPix, 0, trackWidth));
+  }
+
+  /**
+   * This method updates the track gradient image if the Saturation value is
+   * allowed to change (according to the JRadioButtons).
+   */
+  private void updateSTrack()
+  {
+    int[] trackPix = new int[trackWidth * imgHeight];
+
+    float hValue = ((Number) hSpinner.getValue()).intValue() / 360f;
+    float bValue = ((Number) bSpinner.getValue()).intValue() / 100f;
+
+    int trackIndex = 0;
+    for (int j = 0; j < imgHeight; j++)
+      for (int i = 0; i < trackWidth; i++)
+	trackPix[trackIndex++] = Color.HSBtoRGB(hValue,
+	                                        (imgHeight - j * 1f) / imgHeight,
+	                                        bValue) | (255 << 24);
+
+    trackImage = createImage(new MemoryImageSource(trackWidth, imgHeight,
+                                                   trackPix, 0, trackWidth));
+  }
+
+  /**
+   * This method updates the track gradient image if the Brightness value is
+   * allowed to change (according to the JRadioButtons).
+   */
+  private void updateBTrack()
+  {
+    int[] trackPix = new int[trackWidth * imgHeight];
+
+    float hValue = ((Number) hSpinner.getValue()).intValue() / 360f;
+    float sValue = ((Number) sSpinner.getValue()).intValue() / 100f;
+
+    int trackIndex = 0;
+    for (int j = 0; j < imgHeight; j++)
+      for (int i = 0; i < trackWidth; i++)
+	trackPix[trackIndex++] = Color.HSBtoRGB(hValue, sValue,
+	                                        (imgHeight - j * 1f) / imgHeight)
+	                         | (255 << 24);
+
+    trackImage = createImage(new MemoryImageSource(trackWidth, imgHeight,
+                                                   trackPix, 0, trackWidth));
+  }
+}
diff --git a/javax/swing/colorchooser/DefaultPreviewPanel.java b/javax/swing/colorchooser/DefaultPreviewPanel.java
new file mode 100644
index 000000000..93ecfc39a
--- /dev/null
+++ b/javax/swing/colorchooser/DefaultPreviewPanel.java
@@ -0,0 +1,317 @@
+/* DefaultPreviewPanel.java --
+   Copyright (C) 2004 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., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 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.colorchooser;
+
+import java.awt.Color;
+import java.awt.Component;
+import java.awt.Dimension;
+import java.awt.FontMetrics;
+import java.awt.Graphics;
+import java.awt.Insets;
+import javax.swing.JColorChooser;
+import javax.swing.JPanel;
+import javax.swing.SwingUtilities;
+import javax.swing.border.Border;
+
+
+/**
+ * This is the default preview panel for the JColorChooser. The default
+ * preview panel is responsible for displaying the currently selected color
+ * of the JColorChooser.
+ */
+class DefaultPreviewPanel extends JPanel
+{
+  /**
+   * This is the border around the preview panel.
+   */
+  class PreviewBorder implements Border
+  {
+    /** This is the value of the top, bottom, top, and right inset. */
+    private static final int edge = 20;
+
+    /**
+     * This is the distance from the top left corner of the border to the
+     * text.
+     */
+    private static final int lead = 5;
+
+    /** This is the horizontal gap between the text and the border. */
+    private static final int gap = 3;
+
+    /**
+     * This method returns the border insets for the given Component.
+     *
+     * @param c The Component to retrieve insets for.
+     *
+     * @return The insets for the given Component.
+     */
+    public Insets getBorderInsets(Component c)
+    {
+      return new Insets(edge, edge, edge, edge);
+    }
+
+    /**
+     * This method returns whether the border is responsible for painting its
+     * own background.
+     *
+     * @return Whether the border is responsible for painting its own
+     *         background.
+     */
+    public boolean isBorderOpaque()
+    {
+      return true;
+    }
+
+    /**
+     * This method paints the border for the given component with the graphics
+     * object using the given properties.
+     *
+     * @param c The Component to paint the border for.
+     * @param g The Graphics object to paint with.
+     * @param x The x location to paint at.
+     * @param y The y location to paint at.
+     * @param width The width of the component.
+     * @param height The height of the component.
+     */
+    public void paintBorder(Component c, Graphics g, int x, int y, int width,
+                            int height)
+    {
+      Color saved = g.getColor();
+      FontMetrics fm = g.getFontMetrics();
+
+      g.setColor(Color.BLACK);
+      g.drawLine(x + edge / 2, y + edge / 2, x + edge / 2,
+                 y + height - edge / 2);
+      g.drawLine(x + edge / 2, y + height - edge / 2, x + width - edge / 2,
+                 y + height - edge / 2);
+      g.drawLine(x + width - edge / 2, y + edge / 2, x + width - edge / 2,
+                 y + height - edge / 2);
+      g.drawLine(x + edge / 2, y + edge / 2, x + edge / 2 + lead, y + edge / 2);
+
+      int strwidth = fm.stringWidth("Preview");
+
+      g.drawString("Preview", x + edge / 2 + lead + gap,
+                   y + edge / 2 + fm.getAscent() / 2);
+
+      g.drawLine(x + lead + edge / 2 + strwidth + gap * 2, y + edge / 2,
+                 x + width - edge / 2, y + edge / 2);
+
+      g.setColor(saved);
+    }
+  }
+
+  /** A standard large gap size. */
+  private static int largeGap = 6;
+
+  /** A standard small gap size. */
+  private static int smallGap = 2;
+
+  /** The size of each side of the square. */
+  private static int squareSize = 36;
+
+  /** This padding between the text and the edge of its box. */
+  private static int textPadding = 4;
+
+  /** The width of the right most rectangles. */
+  private static int rightSideRectWidth = 60;
+
+  /** The sample text. */
+  private static String sample = "Sample Text   Sample Text";
+
+  /**
+   * Creates a new DefaultPreviewPanel object.
+   */
+  DefaultPreviewPanel()
+  {
+    super();
+    setBorder(new PreviewBorder());
+  }
+
+  /**
+   * This method paints the default preview panel with the given Graphics
+   * object.
+   *
+   * @param g The Graphics object.
+   */
+  public void paint(Graphics g)
+  {
+    super.paint(g);
+    Color currentColor = null;
+    JColorChooser chooser = (JColorChooser) SwingUtilities.getAncestorOfClass(JColorChooser.class,
+                                                                              this);
+    if (chooser != null)
+      currentColor = chooser.getColor();
+
+    Color saved = g.getColor();
+    Insets insets = getInsets();
+
+    int down = insets.top + squareSize + largeGap;
+    int currX = insets.left;
+
+    paintSquare(g, currX, insets.top, Color.WHITE, currentColor, Color.WHITE,
+                -1, -1, -1);
+    paintSquare(g, currX, down, currentColor, null, null, -1, -1, -1);
+
+    currX += squareSize + largeGap;
+
+    paintSquare(g, currX, insets.top, Color.BLACK, currentColor, Color.WHITE,
+                -1, -1, -1);
+    paintSquare(g, currX, down, Color.WHITE, currentColor, null, -1, -1, -1);
+
+    currX += squareSize + largeGap;
+
+    paintSquare(g, currX, insets.top, Color.WHITE, currentColor, Color.BLACK,
+                -1, -1, -1);
+    paintSquare(g, currX, down, Color.BLACK, currentColor, null, -1, -1, -1);
+
+    FontMetrics fm = g.getFontMetrics();
+    int strWidth = fm.stringWidth(sample);
+    int strHeight = fm.getHeight();
+
+    currX += squareSize + largeGap;
+
+    int boxWidth = 2 * textPadding + strWidth;
+    int boxHeight = 2 * textPadding + strHeight;
+
+    int first = insets.top + textPadding;
+    int second = insets.top + boxHeight + smallGap;
+    int third = insets.top + 2 * (boxHeight + smallGap);
+
+    g.setColor(Color.WHITE);
+    g.fillRect(currX, third, boxWidth, boxHeight);
+
+    g.setColor(currentColor);
+    g.drawString(sample, currX + textPadding,
+                 first + textPadding + fm.getAscent());
+
+    g.fillRect(currX, second, boxWidth, boxHeight);
+
+    g.drawString(sample, currX + textPadding,
+                 third + textPadding + fm.getAscent());
+
+    g.setColor(Color.BLACK);
+    g.drawString(sample, currX + textPadding,
+                 second + textPadding + fm.getAscent());
+
+    currX += boxWidth + largeGap;
+
+    g.setColor(Color.WHITE);
+    g.fillRect(currX, insets.top, rightSideRectWidth, squareSize
+               + largeGap / 2);
+
+    g.setColor(currentColor);
+    g.fillRect(currX, insets.top + squareSize + largeGap / 2,
+               rightSideRectWidth, squareSize + largeGap / 2);
+
+    g.setColor(saved);
+  }
+
+  /**
+   * This method creates and paints a square. The square has two smaller
+   * squares inside of it. Each of the three squares has their sizes
+   * determined by the size arguments. If the size is not given (by passing
+   * in -1), then the size is determined automatically.
+   *
+   * @param g The Graphics object to paint with.
+   * @param x The x location to paint at.
+   * @param y The y location to paint at.
+   * @param first The color of the first square.
+   * @param second The color of the second square.
+   * @param third The color of the third square.
+   * @param firstSize The size of the first square.
+   * @param secondSize The size of the second square.
+   * @param thirdSize The size of the third square.
+   */
+  private void paintSquare(Graphics g, int x, int y, Color first,
+                           Color second, Color third, int firstSize,
+                           int secondSize, int thirdSize)
+  {
+    Color saved = g.getColor();
+    if (firstSize == -1)
+      firstSize = squareSize;
+    if (secondSize == -1)
+      secondSize = squareSize * 2 / 3;
+    if (thirdSize == -1)
+      thirdSize = squareSize / 3;
+    int secondOffset = (firstSize - secondSize) / 2;
+    int thirdOffset = (firstSize - thirdSize) / 2;
+
+    if (first == null)
+      return;
+    g.setColor(first);
+    g.fillRect(x, y, firstSize, firstSize);
+    if (second == null)
+      return;
+    g.setColor(second);
+    g.fillRect(x + secondOffset, y + secondOffset, secondSize, secondSize);
+    if (third == null)
+      return;
+    g.setColor(third);
+    g.fillRect(x + thirdOffset, y + thirdOffset, thirdSize, thirdSize);
+
+    g.setColor(saved);
+  }
+
+  /**
+   * This method returns the preferred size of the default preview panel.
+   *
+   * @return The preferred size of the default preview panel.
+   */
+  public Dimension getPreferredSize()
+  {
+    Graphics g = getGraphics();
+    FontMetrics fm = g.getFontMetrics();
+    g.dispose();
+
+    int strWidth = fm.stringWidth(sample);
+    int strHeight = fm.getHeight();
+
+    int h1 = (strHeight + 2 * textPadding) * 3 + 2 * smallGap;
+    int h2 = 2 * squareSize + largeGap;
+
+    int height = Math.max(h1, h2);
+
+    int width = 3 * (squareSize + largeGap) + strWidth + 2 * textPadding
+                + largeGap + rightSideRectWidth;
+
+    Insets insets = getInsets();
+
+    return new Dimension(width + insets.right + insets.left,
+                         height + insets.top + insets.bottom);
+  }
+}
diff --git a/javax/swing/colorchooser/DefaultRGBChooserPanel.java b/javax/swing/colorchooser/DefaultRGBChooserPanel.java
new file mode 100644
index 000000000..f6c22e885
--- /dev/null
+++ b/javax/swing/colorchooser/DefaultRGBChooserPanel.java
@@ -0,0 +1,377 @@
+/* DefaultRGHChooserPanel.java --
+   Copyright (C) 2004 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., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 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.colorchooser;
+
+import java.awt.BorderLayout;
+import java.awt.Color;
+import java.awt.FlowLayout;
+import java.awt.Graphics;
+import java.awt.GridBagConstraints;
+import java.awt.GridBagLayout;
+import javax.swing.Icon;
+import javax.swing.JColorChooser;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.JSlider;
+import javax.swing.JSpinner;
+import javax.swing.SpinnerNumberModel;
+import javax.swing.SwingConstants;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+
+
+/**
+ * This is the default RGB panel for the JColorChooser. The color is selected
+ * using three sliders that represent the RGB values.
+ */
+public class DefaultRGBChooserPanel extends AbstractColorChooserPanel
+{
+  /**
+   * This class handles the slider value changes for all three sliders.
+   */
+  class SliderHandler implements ChangeListener
+  {
+    /**
+     * This method is called whenever any of the slider values change.
+     *
+     * @param e The ChangeEvent.
+     */
+    public void stateChanged(ChangeEvent e)
+    {
+      if (internalChange)
+	return;
+      int color = R.getValue() << 16 | G.getValue() << 8 | B.getValue();
+
+      getColorSelectionModel().setSelectedColor(new Color(color));
+    }
+  }
+
+  /**
+   * This class handles the Spinner values changing.
+   */
+  class SpinnerHandler implements ChangeListener
+  {
+    /**
+     * This method is called whenever any of the JSpinners change values.
+     *
+     * @param e The ChangeEvent.
+     */
+    public void stateChanged(ChangeEvent e)
+    {
+      if (internalChange)
+	return;
+      int red = ((Number) RSpinner.getValue()).intValue();
+      int green = ((Number) GSpinner.getValue()).intValue();
+      int blue = ((Number) BSpinner.getValue()).intValue();
+
+      int color = red << 16 | green << 8 | blue;
+
+      getColorSelectionModel().setSelectedColor(new Color(color));
+    }
+  }
+
+  /**
+   * Whether the color change was initiated from the slider or spinner rather
+   * than externally.
+   */
+  private transient boolean internalChange = false;
+
+  /** The ChangeListener for the sliders. */
+  private transient ChangeListener colorChanger;
+
+  /** The ChangeListener for the spinners. */
+  private transient ChangeListener spinnerHandler;
+
+  /** The slider that handles the red values. */
+  private transient JSlider R;
+
+  /** The slider that handles the green values. */
+  private transient JSlider G;
+
+  /** The slider that handles the blue values. */
+  private transient JSlider B;
+
+  /** The label for the red slider. */
+  private transient JLabel RLabel;
+
+  /** The label for the green slider. */
+  private transient JLabel GLabel;
+
+  /** The label for the blue slider. */
+  private transient JLabel BLabel;
+
+  /** The spinner that handles the red values. */
+  private transient JSpinner RSpinner;
+
+  /** The spinner that handles the green values. */
+  private transient JSpinner GSpinner;
+
+  /** The spinner that handles the blue values. */
+  private transient JSpinner BSpinner;
+
+  /**
+   * Creates a new DefaultRGBChooserPanel object.
+   */
+  public DefaultRGBChooserPanel()
+  {
+    super();
+  }
+
+  /**
+   * This method returns the name displayed in the JTabbedPane.
+   *
+   * @return The name displayed in the JTabbedPane.
+   */
+  public String getDisplayName()
+  {
+    return "RGB";
+  }
+
+  /**
+   * This method updates the chooser panel with the new color chosen in the
+   * JColorChooser.
+   */
+  public void updateChooser()
+  {
+    Color c = getColorFromModel();
+    int rgb = c.getRGB();
+
+    int red = rgb >> 16 & 0xff;
+    int green = rgb >> 8 & 0xff;
+    int blue = rgb & 0xff;
+
+    internalChange = true;
+
+    if (R != null)
+      R.setValue(red);
+    if (RSpinner != null)
+      RSpinner.setValue(new Integer(red));
+    if (G != null)
+      G.setValue(green);
+    if (GSpinner != null)
+      GSpinner.setValue(new Integer(green));
+    if (B != null)
+      B.setValue(blue);
+    if (BSpinner != null)
+      BSpinner.setValue(new Integer(blue));
+
+    internalChange = false;
+
+    revalidate();
+    repaint();
+  }
+
+  /**
+   * This method builds the chooser panel.
+   */
+  protected void buildChooser()
+  {
+    setLayout(new GridBagLayout());
+
+    RLabel = new JLabel("Red");
+    RLabel.setDisplayedMnemonic('d');
+    GLabel = new JLabel("Green");
+    GLabel.setDisplayedMnemonic('n');
+    BLabel = new JLabel("Blue");
+    BLabel.setDisplayedMnemonic('B');
+
+    R = new JSlider(SwingConstants.HORIZONTAL, 0, 255, 255);
+    G = new JSlider(SwingConstants.HORIZONTAL, 0, 255, 255);
+    B = new JSlider(SwingConstants.HORIZONTAL, 0, 255, 255);
+
+    R.setPaintTicks(true);
+    R.setSnapToTicks(false);
+    G.setPaintTicks(true);
+    G.setSnapToTicks(false);
+    B.setPaintTicks(true);
+    B.setSnapToTicks(false);
+
+    R.setLabelTable(R.createStandardLabels(85));
+    R.setPaintLabels(true);
+    G.setLabelTable(G.createStandardLabels(85));
+    G.setPaintLabels(true);
+    B.setLabelTable(B.createStandardLabels(85));
+    B.setPaintLabels(true);
+
+    R.setMajorTickSpacing(85);
+    G.setMajorTickSpacing(85);
+    B.setMajorTickSpacing(85);
+
+    R.setMinorTickSpacing(17);
+    G.setMinorTickSpacing(17);
+    B.setMinorTickSpacing(17);
+
+    RSpinner = new JSpinner(new SpinnerNumberModel(R.getValue(),
+                                                   R.getMinimum(),
+                                                   R.getMaximum(), 1));
+    GSpinner = new JSpinner(new SpinnerNumberModel(G.getValue(),
+                                                   G.getMinimum(),
+                                                   G.getMaximum(), 1));
+    BSpinner = new JSpinner(new SpinnerNumberModel(B.getValue(),
+                                                   B.getMinimum(),
+                                                   B.getMaximum(), 1));
+
+    RLabel.setLabelFor(R);
+    GLabel.setLabelFor(G);
+    BLabel.setLabelFor(B);
+
+    GridBagConstraints bag = new GridBagConstraints();
+    bag.fill = GridBagConstraints.VERTICAL;
+
+    bag.gridx = 0;
+    bag.gridy = 0;
+    add(RLabel, bag);
+
+    bag.gridx = 1;
+    add(R, bag);
+
+    bag.gridx = 2;
+    add(RSpinner, bag);
+
+    bag.gridx = 0;
+    bag.gridy = 1;
+    add(GLabel, bag);
+
+    bag.gridx = 1;
+    add(G, bag);
+
+    bag.gridx = 2;
+    add(GSpinner, bag);
+
+    bag.gridx = 0;
+    bag.gridy = 2;
+    add(BLabel, bag);
+
+    bag.gridx = 1;
+    add(B, bag);
+
+    bag.gridx = 2;
+    add(BSpinner, bag);
+
+    installListeners();
+  }
+
+  /**
+   * This method uninstalls the chooser panel from the JColorChooser.
+   *
+   * @param chooser The JColorChooser to remove this chooser panel from.
+   */
+  public void uninstallChooserPanel(JColorChooser chooser)
+  {
+    uninstallListeners();
+    removeAll();
+
+    R = null;
+    G = null;
+    B = null;
+
+    RSpinner = null;
+    GSpinner = null;
+    BSpinner = null;
+
+    super.uninstallChooserPanel(chooser);
+  }
+
+  /**
+   * This method uninstalls any listeners that were added by the chooser
+   * panel.
+   */
+  private void uninstallListeners()
+  {
+    R.removeChangeListener(colorChanger);
+    G.removeChangeListener(colorChanger);
+    B.removeChangeListener(colorChanger);
+
+    colorChanger = null;
+
+    RSpinner.removeChangeListener(spinnerHandler);
+    GSpinner.removeChangeListener(spinnerHandler);
+    BSpinner.removeChangeListener(spinnerHandler);
+
+    spinnerHandler = null;
+  }
+
+  /**
+   * This method installs any listeners that the chooser panel needs to
+   * operate.
+   */
+  private void installListeners()
+  {
+    colorChanger = new SliderHandler();
+
+    R.addChangeListener(colorChanger);
+    G.addChangeListener(colorChanger);
+    B.addChangeListener(colorChanger);
+
+    spinnerHandler = new SpinnerHandler();
+
+    RSpinner.addChangeListener(spinnerHandler);
+    GSpinner.addChangeListener(spinnerHandler);
+    BSpinner.addChangeListener(spinnerHandler);
+  }
+
+  /**
+   * This method returns the small display icon.
+   *
+   * @return The small display icon.
+   */
+  public Icon getSmallDisplayIcon()
+  {
+    return null;
+  }
+
+  /**
+   * This method returns the large display icon.
+   *
+   * @return The large display icon.
+   */
+  public Icon getLargeDisplayIcon()
+  {
+    return null;
+  }
+
+  /**
+   * This method paints the default RGB chooser panel.
+   *
+   * @param g The Graphics object to paint with.
+   */
+  public void paint(Graphics g)
+  {
+    super.paint(g);
+  }
+}
diff --git a/javax/swing/colorchooser/DefaultSwatchChooserPanel.java b/javax/swing/colorchooser/DefaultSwatchChooserPanel.java
new file mode 100644
index 000000000..1413a5b2d
--- /dev/null
+++ b/javax/swing/colorchooser/DefaultSwatchChooserPanel.java
@@ -0,0 +1,891 @@
+/* DefaultSwatchChooserPanel.java --
+   Copyright (C) 2004 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., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 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.colorchooser;
+
+import java.awt.BorderLayout;
+import java.awt.Color;
+import java.awt.Component;
+import java.awt.Container;
+import java.awt.Dimension;
+import java.awt.Graphics;
+import java.awt.Insets;
+import java.awt.LayoutManager;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+import java.awt.event.MouseListener;
+import javax.swing.Icon;
+import javax.swing.JColorChooser;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+
+
+/**
+ * This class is the DefaultSwatchChooserPanel. This chooser panel displays a
+ * set of colors that can be picked. Recently picked items will go into a
+ * side panel so the user can see the history of the chosen colors.
+ */
+class DefaultSwatchChooserPanel extends AbstractColorChooserPanel
+{
+  /** The main panel that holds the set of choosable colors. */
+  MainSwatchPanel mainPalette;
+
+  /** A panel that holds the recent colors. */
+  RecentSwatchPanel recentPalette;
+
+  /** The mouse handlers for the panels. */
+  MouseListener mouseHandler;
+
+  /**
+   * This the base class for all swatch panels. Swatch panels are panels that
+   * hold a set of blocks where colors are displayed.
+   */
+  abstract static class SwatchPanel extends JPanel
+  {
+    /** The width of each block. */
+    protected int cellWidth = 10;
+
+    /** The height of each block. */
+    protected int cellHeight = 10;
+
+    /** The gap between blocks. */
+    protected int gap = 1;
+
+    /** The number of rows in the swatch panel. */
+    protected int numRows;
+
+    /** The number of columns in the swatch panel. */
+    protected int numCols;
+
+    /**
+     * Creates a new SwatchPanel object.
+     */
+    SwatchPanel()
+    {
+      super();
+      setBackground(Color.WHITE);
+    }
+
+    /**
+     * This method returns the preferred size of the swatch panel based on the
+     * number of rows and columns and the size of each cell.
+     *
+     * @return The preferred size of the swatch panel.
+     */
+    public Dimension getPreferredSize()
+    {
+      int height = numRows * cellHeight + (numRows - 1) * gap;
+      int width = numCols * cellWidth + (numCols - 1) * gap;
+      Insets insets = getInsets();
+
+      return new Dimension(width + insets.left + insets.right,
+                           height + insets.top + insets.bottom);
+    }
+
+    /**
+     * This method returns the color for the given position.
+     *
+     * @param x The x coordinate of the position.
+     * @param y The y coordinate of the position.
+     *
+     * @return The color at the given position.
+     */
+    public abstract Color getColorForPosition(int x, int y);
+
+    /**
+     * This method initializes the colors for the swatch panel.
+     */
+    protected abstract void initializeColors();
+  }
+
+  /**
+   * This is the main swatch panel. This panel sits in the middle and allows a
+   * set of colors to be picked which will move to the recent swatch panel.
+   */
+  static class MainSwatchPanel extends SwatchPanel
+  {
+    /** The color describing (204, 255, 255) */
+    public static final Color C204255255 = new Color(204, 204, 255);
+
+    /** The color describing (255, 204, 204) */
+    public static final Color C255204204 = new Color(255, 204, 204);
+
+    /** The color describing (204, 255, 204) */
+    public static final Color C204255204 = new Color(204, 255, 204);
+
+    /** The color describing (204, 204, 204) */
+    public static final Color C204204204 = new Color(204, 204, 204);
+
+    /** The color (153, 153, 255). */
+    public static final Color C153153255 = new Color(153, 153, 255);
+
+    /** The color (51, 51, 255). */
+    public static final Color C051051255 = new Color(51, 51, 255);
+
+    /** The color (153, 0, 153). */
+    public static final Color C153000153 = new Color(153, 0, 153);
+
+    /** The color (0, 51, 51). */
+    public static final Color C000051051 = new Color(0, 51, 51);
+
+    /** The color (51, 0, 51). */
+    public static final Color C051000051 = new Color(51, 0, 51);
+
+    /** The color (51, 51, 0). */
+    public static final Color C051051000 = new Color(51, 51, 0);
+
+    /** The color (102, 102, 0). */
+    public static final Color C102102000 = new Color(102, 102, 0);
+
+    /** The color (153, 255, 153). */
+    public static final Color C153255153 = new Color(153, 255, 153);
+
+    /** The color (102, 255, 102). */
+    public static final Color C102255102 = new Color(102, 255, 102);
+
+    /** The color (0, 102, 102). */
+    public static final Color C000102102 = new Color(0, 102, 102);
+
+    /** The color (102, 0, 102). */
+    public static final Color C102000102 = new Color(102, 0, 102);
+
+    /** The color (0, 153, 153). */
+    public static final Color C000153153 = new Color(0, 153, 153);
+
+    /** The color (153, 153, 0). */
+    public static final Color C153153000 = new Color(153, 153, 0);
+
+    /** The color (204, 204, 0). */
+    public static final Color C204204000 = new Color(204, 204, 0);
+
+    /** The color (204, 0, 204). */
+    public static final Color C204000204 = new Color(204, 0, 204);
+
+    /** The color (0, 204, 204). */
+    public static final Color C000204204 = new Color(0, 204, 204);
+
+    /** The color (51, 255, 51). */
+    public static final Color C051255051 = new Color(51, 255, 51);
+
+    /** The color (255, 51, 51). */
+    public static final Color C255051051 = new Color(255, 51, 51);
+
+    /** The color (255, 102, 102). */
+    public static final Color C255102102 = new Color(255, 102, 102);
+
+    /** The color (102, 102, 255). */
+    public static final Color C102102255 = new Color(102, 102, 255);
+
+    /** The color (255, 153, 153). */
+    public static final Color C255153153 = new Color(255, 153, 153);
+    static Color[] colors = 
+                            {
+                              // Row 1
+    Color.WHITE, new Color(204, 255, 255), C204255255, C204255255, C204255255,
+                              C204255255, C204255255, C204255255, C204255255,
+                              C204255255, C204255255, new Color(255, 204, 255),
+                              C255204204, C255204204, C255204204, C255204204,
+                              C255204204, C255204204, C255204204, C255204204,
+                              C255204204, new Color(255, 255, 204), C204255204,
+                              C204255204, C204255204, C204255204, C204255204,
+                              C204255204, C204255204, C204255204, C204255204,
+                              
+    // Row 2
+    C204204204, new Color(153, 255, 255), new Color(153, 204, 255), C153153255,
+                              C153153255, C153153255, C153153255, C153153255,
+                              C153153255, C153153255, new Color(204, 153, 255),
+                              new Color(255, 153, 255),
+                              new Color(255, 153, 204), C255153153, C255153153,
+                              C255153153, C255153153, C255153153, C255153153,
+                              C255153153, new Color(255, 204, 153),
+                              new Color(255, 255, 153),
+                              new Color(204, 255, 153), C153255153, C153255153,
+                              C153255153, C153255153, C153255153, C153255153,
+                              C153255153, new Color(153, 255, 204),
+                              
+    // Row 3
+    C204204204, new Color(102, 255, 255), new Color(102, 204, 255),
+                              new Color(102, 153, 255), C102102255, C102102255,
+                              C102102255, C102102255, C102102255,
+                              new Color(153, 102, 255),
+                              new Color(204, 102, 255),
+                              new Color(255, 102, 255),
+                              new Color(255, 102, 204),
+                              new Color(255, 102, 153), C255102102, C255102102,
+                              C255102102, C255102102, C255102102,
+                              new Color(255, 153, 102),
+                              new Color(255, 204, 102),
+                              new Color(255, 255, 102),
+                              new Color(204, 255, 102),
+                              new Color(153, 255, 102), C102255102, C102255102,
+                              C102255102, C102255102, C102255102,
+                              new Color(102, 255, 153),
+                              new Color(102, 255, 204),
+                              
+    // Row 4
+    new Color(153, 153, 153), new Color(51, 255, 255), new Color(51, 204, 255),
+                              new Color(51, 153, 255), new Color(51, 102, 255),
+                              C051051255, C051051255, C051051255,
+                              new Color(102, 51, 255), new Color(153, 51, 255),
+                              new Color(204, 51, 255), new Color(255, 51, 255),
+                              new Color(255, 51, 204), new Color(255, 51, 153),
+                              new Color(255, 51, 102), C255051051, C255051051,
+                              C255051051, new Color(255, 102, 51),
+                              new Color(255, 153, 51), new Color(255, 204, 51),
+                              new Color(255, 255, 51), new Color(204, 255, 51),
+                              new Color(153, 255, 51), new Color(102, 255, 51),
+                              C051255051, C051255051, C051255051,
+                              new Color(51, 255, 102), new Color(51, 255, 153),
+                              new Color(51, 255, 204),
+                              
+    // Row 5
+    new Color(153, 153, 153), new Color(0, 255, 255), new Color(0, 204, 255),
+                              new Color(0, 153, 255), new Color(0, 102, 255),
+                              new Color(0, 51, 255), new Color(0, 0, 255),
+                              new Color(51, 0, 255), new Color(102, 0, 255),
+                              new Color(153, 0, 255), new Color(204, 0, 255),
+                              new Color(255, 0, 255), new Color(255, 0, 204),
+                              new Color(255, 0, 153), new Color(255, 0, 102),
+                              new Color(255, 0, 51), new Color(255, 0, 0),
+                              new Color(255, 51, 0), new Color(255, 102, 0),
+                              new Color(255, 153, 0), new Color(255, 204, 0),
+                              new Color(255, 255, 0), new Color(204, 255, 0),
+                              new Color(153, 255, 0), new Color(102, 255, 0),
+                              new Color(51, 255, 0), new Color(0, 255, 0),
+                              new Color(0, 255, 51), new Color(0, 255, 102),
+                              new Color(0, 255, 153), new Color(0, 255, 204),
+                              
+    // Row 6
+    new Color(102, 102, 102), C000204204, C000204204, new Color(0, 153, 204),
+                              new Color(0, 102, 204), new Color(0, 51, 204),
+                              new Color(0, 0, 204), new Color(51, 0, 204),
+                              new Color(102, 0, 204), new Color(153, 0, 204),
+                              C204000204, C204000204, C204000204,
+                              new Color(204, 0, 153), new Color(204, 0, 102),
+                              new Color(204, 0, 51), new Color(204, 0, 0),
+                              new Color(204, 51, 0), new Color(204, 102, 0),
+                              new Color(204, 153, 0), C204204000, C204204000,
+                              C204204000, new Color(153, 204, 0),
+                              new Color(102, 204, 0), new Color(51, 204, 0),
+                              new Color(0, 204, 0), new Color(0, 204, 51),
+                              new Color(0, 204, 102), new Color(0, 204, 153),
+                              new Color(0, 204, 204),
+                              
+    // Row 7
+    new Color(102, 102, 102), C000153153, C000153153, C000153153,
+                              new Color(0, 102, 153), new Color(0, 51, 153),
+                              new Color(0, 0, 153), new Color(51, 0, 153),
+                              new Color(102, 0, 153), C153000153, C153000153,
+                              C153000153, C153000153, C153000153,
+                              new Color(153, 0, 102), new Color(153, 0, 51),
+                              new Color(153, 0, 0), new Color(153, 51, 0),
+                              new Color(153, 102, 0), C153153000, C153153000,
+                              C153153000, C153153000, C153153000,
+                              new Color(102, 153, 0), new Color(51, 153, 0),
+                              new Color(0, 153, 0), new Color(0, 153, 51),
+                              new Color(0, 153, 102), C000153153, C000153153,
+                              
+    // Row 8
+    new Color(51, 51, 51), C000102102, C000102102, C000102102, C000102102,
+                              new Color(0, 51, 102), new Color(0, 0, 102),
+                              new Color(51, 0, 102), C102000102, C102000102,
+                              C102000102, C102000102, C102000102, C102000102,
+                              C102000102, new Color(102, 0, 51),
+                              new Color(102, 0, 0), new Color(102, 51, 0),
+                              C102102000, C102102000, C102102000, C102102000,
+                              C102102000, C102102000, C102102000,
+                              new Color(51, 102, 0), new Color(0, 102, 0),
+                              new Color(0, 102, 51), C000102102, C000102102,
+                              C000102102,
+                              
+    // Row 9.
+    Color.BLACK, C000051051, C000051051, C000051051, C000051051, C000051051,
+                              new Color(0, 0, 51), C051000051, C051000051,
+                              C051000051, C051000051, C051000051, C051000051,
+                              C051000051, C051000051, C051000051,
+                              new Color(51, 0, 0), C051051000, C051051000,
+                              C051051000, C051051000, C051051000, C051051000,
+                              C051051000, C051051000, new Color(0, 51, 0),
+                              C000051051, C000051051, C000051051, C000051051,
+                              new Color(51, 51, 51)
+                            };
+
+    /**
+     * Creates a new MainSwatchPanel object.
+     */
+    MainSwatchPanel()
+    {
+      super();
+      numCols = 31;
+      numRows = 9;
+      initializeColors();
+      revalidate();
+    }
+
+    /**
+     * This method returns the color for the given position.
+     *
+     * @param x The x location for the position.
+     * @param y The y location for the position.
+     *
+     * @return The color for the given position.
+     */
+    public Color getColorForPosition(int x, int y)
+    {
+      if (x % (cellWidth + gap) > cellWidth
+          || y % (cellHeight + gap) > cellHeight)
+	// position is located in gap.
+	return null;
+
+      int row = y / (cellHeight + gap);
+      int col = x / (cellWidth + gap);
+      return colors[row * numCols + col];
+    }
+
+    /**
+     * This method initializes the colors for the main swatch panel.
+     */
+    protected void initializeColors()
+    {
+      // Unnecessary
+    }
+
+    /**
+     * This method paints the main graphics panel with the given Graphics
+     * object.
+     *
+     * @param graphics The Graphics object to paint with.
+     */
+    public void paint(Graphics graphics)
+    {
+      int index = 0;
+      Insets insets = getInsets();
+      int currX = insets.left;
+      int currY = insets.top;
+      Color saved = graphics.getColor();
+
+      for (int i = 0; i < numRows; i++)
+        {
+	  for (int j = 0; j < numCols; j++)
+	    {
+	      graphics.setColor(colors[index++]);
+	      graphics.fill3DRect(currX, currY, cellWidth, cellHeight, true);
+	      currX += gap + cellWidth;
+	    }
+	  currX = insets.left;
+	  currY += gap + cellHeight;
+        }
+      graphics.setColor(saved);
+    }
+
+    /**
+     * This method returns the tooltip text for the given MouseEvent.
+     *
+     * @param e The MouseEvent to find tooltip text for.
+     *
+     * @return The tooltip text.
+     */
+    public String getToolTipText(MouseEvent e)
+    {
+      Color c = getColorForPosition(e.getX(), e.getY());
+      if (c == null)
+	return null;
+      return (c.getRed() + "," + c.getGreen() + "," + c.getBlue());
+    }
+  }
+
+  /**
+   * This class is the recent swatch panel. It holds recently selected colors.
+   */
+  public static class RecentSwatchPanel extends SwatchPanel
+  {
+    /** The array for storing recently stored colors. */
+    Color[] colors;
+
+    /** The default color. */
+    public static final Color defaultColor = Color.GRAY;
+
+    /** The index of the array that is the start. */
+    int start = 0;
+
+    /**
+     * Creates a new RecentSwatchPanel object.
+     */
+    RecentSwatchPanel()
+    {
+      super();
+      numCols = 5;
+      numRows = 7;
+      initializeColors();
+      revalidate();
+    }
+
+    /**
+     * This method returns the color for the given position.
+     *
+     * @param x The x coordinate of the position.
+     * @param y The y coordinate of the position.
+     *
+     * @return The color for the given position.
+     */
+    public Color getColorForPosition(int x, int y)
+    {
+      if (x % (cellWidth + gap) > cellWidth
+          || y % (cellHeight + gap) > cellHeight)
+	// position is located in gap.
+	return null;
+
+      int row = y / (cellHeight + gap);
+      int col = x / (cellWidth + gap);
+
+      return colors[getIndexForCell(row, col)];
+    }
+
+    /**
+     * This method initializes the colors for the recent swatch panel.
+     */
+    protected void initializeColors()
+    {
+      colors = new Color[numRows * numCols];
+      for (int i = 0; i < colors.length; i++)
+	colors[i] = defaultColor;
+    }
+
+    /**
+     * This method returns the array index for the given row and column.
+     *
+     * @param row The row.
+     * @param col The column.
+     *
+     * @return The array index for the given row and column.
+     */
+    private int getIndexForCell(int row, int col)
+    {
+      return ((row * numCols) + col + start) % (numRows * numCols);
+    }
+
+    /**
+     * This method adds the given color to the beginning of the swatch panel.
+     *
+     * @param c The color to add.
+     */
+    private void addColorToQueue(Color c)
+    {
+      if (--start == -1)
+	start = numRows * numCols - 1;
+
+      colors[start] = c;
+    }
+
+    /**
+     * This method paints the panel with the given Graphics object.
+     *
+     * @param g The Graphics object to paint with.
+     */
+    public void paint(Graphics g)
+    {
+      Color saved = g.getColor();
+      Insets insets = getInsets();
+      int currX = insets.left;
+      int currY = insets.top;
+
+      for (int i = 0; i < numRows; i++)
+        {
+	  for (int j = 0; j < numCols; j++)
+	    {
+	      g.setColor(colors[getIndexForCell(i, j)]);
+	      g.fill3DRect(currX, currY, cellWidth, cellHeight, true);
+	      currX += cellWidth + gap;
+	    }
+	  currX = insets.left;
+	  currY += cellWidth + gap;
+        }
+    }
+
+    /**
+     * This method returns the tooltip text for the given MouseEvent.
+     *
+     * @param e The MouseEvent.
+     *
+     * @return The tooltip text.
+     */
+    public String getToolTipText(MouseEvent e)
+    {
+      Color c = getColorForPosition(e.getX(), e.getY());
+      if (c == null)
+	return null;
+      return c.getRed() + "," + c.getGreen() + "," + c.getBlue();
+    }
+  }
+
+  /**
+   * This class handles mouse events for the two swatch panels.
+   */
+  class MouseHandler extends MouseAdapter
+  {
+    /**
+     * This method is called whenever the mouse is pressed.
+     *
+     * @param e The MouseEvent.
+     */
+    public void mousePressed(MouseEvent e)
+    {
+      SwatchPanel panel = (SwatchPanel) e.getSource();
+      Color c = panel.getColorForPosition(e.getX(), e.getY());
+      recentPalette.addColorToQueue(c);
+      DefaultSwatchChooserPanel.this.getColorSelectionModel().setSelectedColor(c);
+      DefaultSwatchChooserPanel.this.repaint();
+    }
+  }
+
+  /**
+   * This is the layout manager for the main panel.
+   */
+  static class MainPanelLayout implements LayoutManager
+  {
+    /**
+     * This method is called when a new component is added to the container.
+     *
+     * @param name The name of the component.
+     * @param comp The added component.
+     */
+    public void addLayoutComponent(String name, Component comp)
+    {
+    }
+
+    /**
+     * This method is called to set the size and position of the child
+     * components for the given container.
+     *
+     * @param parent The container to lay out.
+     */
+    public void layoutContainer(Container parent)
+    {
+      Component[] comps = parent.getComponents();
+      Insets insets = parent.getInsets();
+      Dimension[] pref = new Dimension[comps.length];
+
+      int xpos = 0;
+      int ypos = 0;
+      int maxHeight = 0;
+      int totalWidth = 0;
+
+      for (int i = 0; i < comps.length; i++)
+        {
+	  pref[i] = comps[i].getPreferredSize();
+	  if (pref[i] == null)
+	    return;
+	  maxHeight = Math.max(maxHeight, pref[i].height);
+	  totalWidth += pref[i].width;
+        }
+
+      ypos = (parent.getSize().height - maxHeight) / 2 + insets.top;
+      xpos = insets.left + (parent.getSize().width - totalWidth) / 2;
+
+      for (int i = 0; i < comps.length; i++)
+        {
+	  if (pref[i] == null)
+	    continue;
+	  comps[i].setBounds(xpos, ypos, pref[i].width, pref[i].height);
+	  xpos += pref[i].width;
+        }
+    }
+
+    /**
+     * This method is called when a component is removed from the container.
+     *
+     * @param comp The component that was removed.
+     */
+    public void removeLayoutComponent(Component comp)
+    {
+    }
+
+    /**
+     * This methods calculates the minimum layout size for the container.
+     *
+     * @param parent The container.
+     *
+     * @return The minimum layout size.
+     */
+    public Dimension minimumLayoutSize(Container parent)
+    {
+      return preferredLayoutSize(parent);
+    }
+
+    /**
+     * This method returns the preferred layout size for the given container.
+     *
+     * @param parent The container.
+     *
+     * @return The preferred layout size.
+     */
+    public Dimension preferredLayoutSize(Container parent)
+    {
+      int xmax = 0;
+      int ymax = 0;
+
+      Component[] comps = parent.getComponents();
+      Dimension pref;
+
+      for (int i = 0; i < comps.length; i++)
+        {
+	  pref = comps[i].getPreferredSize();
+	  if (pref == null)
+	    continue;
+	  xmax += pref.width;
+	  ymax = Math.max(ymax, pref.height);
+        }
+
+      Insets insets = parent.getInsets();
+
+      return new Dimension(insets.left + insets.right + xmax,
+                           insets.top + insets.bottom + ymax);
+    }
+  }
+
+  /**
+   * This is the layout manager for the recent swatch panel.
+   */
+  static class RecentPanelLayout implements LayoutManager
+  {
+    /**
+     * This method is called when a component is added to the container.
+     *
+     * @param name The name of the component.
+     * @param comp The added component.
+     */
+    public void addLayoutComponent(String name, Component comp)
+    {
+      // Nothing needs to be done.
+    }
+
+    /**
+     * This method sets the size and position of the child components of the
+     * given container.
+     *
+     * @param parent The container to lay out.
+     */
+    public void layoutContainer(Container parent)
+    {
+      Component[] comps = parent.getComponents();
+      Dimension parentSize = parent.getSize();
+      Insets insets = parent.getInsets();
+      int currY = insets.top;
+      Dimension pref;
+
+      for (int i = 0; i < comps.length; i++)
+        {
+	  pref = comps[i].getPreferredSize();
+	  if (pref == null)
+	    continue;
+	  comps[i].setBounds(insets.left, currY, pref.width, pref.height);
+	  currY += pref.height;
+        }
+    }
+
+    /**
+     * This method calculates the minimum layout size for the given container.
+     *
+     * @param parent The container.
+     *
+     * @return The minimum layout size.
+     */
+    public Dimension minimumLayoutSize(Container parent)
+    {
+      return preferredLayoutSize(parent);
+    }
+
+    /**
+     * This method calculates the preferred layout size for the given
+     * container.
+     *
+     * @param parent The container.
+     *
+     * @return The preferred layout size.
+     */
+    public Dimension preferredLayoutSize(Container parent)
+    {
+      int width = 0;
+      int height = 0;
+      Insets insets = parent.getInsets();
+      Component[] comps = parent.getComponents();
+      Dimension pref;
+      for (int i = 0; i < comps.length; i++)
+        {
+	  pref = comps[i].getPreferredSize();
+	  if (pref != null)
+	    {
+	      width = Math.max(width, pref.width);
+	      height += pref.height;
+	    }
+        }
+
+      return new Dimension(width + insets.left + insets.right,
+                           height + insets.top + insets.bottom);
+    }
+
+    /**
+     * This method is called whenever a component is removed from the
+     * container.
+     *
+     * @param comp The removed component.
+     */
+    public void removeLayoutComponent(Component comp)
+    {
+      // Nothing needs to be done.
+    }
+  }
+
+  /**
+   * Creates a new DefaultSwatchChooserPanel object.
+   */
+  DefaultSwatchChooserPanel()
+  {
+    super();
+  }
+
+  /**
+   * This method updates the chooser panel with the new value from the
+   * JColorChooser.
+   */
+  public void updateChooser()
+  {
+  }
+
+  /**
+   * This method builds the chooser panel.
+   */
+  protected void buildChooser()
+  {
+    // The structure of the swatch panel is:
+    // One large panel (minus the insets).
+    // Inside that panel, there are two panels, one holds the palette.
+    // The other holds the label and the recent colors palette.
+    // The two palettes are two custom swatch panels.
+    setLayout(new MainPanelLayout());
+
+    JPanel mainPaletteHolder = new JPanel();
+    JPanel recentPaletteHolder = new JPanel();
+
+    mainPalette = new MainSwatchPanel();
+    recentPalette = new RecentSwatchPanel();
+    JLabel label = new JLabel("Recent:");
+
+    mouseHandler = new MouseHandler();
+    mainPalette.addMouseListener(mouseHandler);
+    recentPalette.addMouseListener(mouseHandler);
+
+    mainPaletteHolder.setLayout(new BorderLayout());
+    mainPaletteHolder.add(mainPalette, BorderLayout.CENTER);
+
+    recentPaletteHolder.setLayout(new RecentPanelLayout());
+    recentPaletteHolder.add(label);
+    recentPaletteHolder.add(recentPalette);
+
+    JPanel main = new JPanel();
+    main.add(mainPaletteHolder);
+    main.add(recentPaletteHolder);
+
+    this.add(main);
+  }
+
+  /**
+   * This method removes the chooser panel from the JColorChooser.
+   *
+   * @param chooser The JColorChooser this panel is being removed from.
+   */
+  public void uninstallChooserPanel(JColorChooser chooser)
+  {
+    recentPalette = null;
+    mainPalette = null;
+
+    removeAll();
+    super.uninstallChooserPanel(chooser);
+  }
+
+  /**
+   * This method returns the JTabbedPane displayed name.
+   *
+   * @return The name displayed in the JTabbedPane.
+   */
+  public String getDisplayName()
+  {
+    return "Swatches";
+  }
+
+  /**
+   * This method returns the small display icon.
+   *
+   * @return The small display icon.
+   */
+  public Icon getSmallDisplayIcon()
+  {
+    return null;
+  }
+
+  /**
+   * This method returns the large display icon.
+   *
+   * @return The large display icon.
+   */
+  public Icon getLargeDisplayIcon()
+  {
+    return null;
+  }
+
+  /**
+   * This method paints the chooser panel with the given Graphics object.
+   *
+   * @param g The Graphics object to paint with.
+   */
+  public void paint(Graphics g)
+  {
+    super.paint(g);
+  }
+
+  /**
+   * This method returns the tooltip text for the given MouseEvent.
+   *
+   * @param e The MouseEvent.
+   *
+   * @return The tooltip text.
+   */
+  public String getToolTipText(MouseEvent e)
+  {
+    return null;
+  }
+}